Class AeSdk

Basic AeSdk class implements:

node selector,
integrated compiler support,
wrappers of account methods mapped to the current account.

Hierarchy

AeSdkBase
- AeSdk
  - AeSdkWallet

Index

Constructors

constructor

new AeSdk(__namedParameters?: {
    accounts?: AccountBase[];
} & AeSdkMethodsOptions & {
    nodes?: {
        instance: Node;
        name: string;
    }[];
}): AeSdk
Parameters
- __namedParameters: {
      accounts?: AccountBase[];
  } & AeSdkMethodsOptions & {
      nodes?: {
          instance: Node;
          name: string;
      }[];
  } = {}
Returns AeSdk
Overrides AeSdkBase.constructor
- Defined in AeSdk.ts:12

Properties

_getPollInterval

_getPollInterval: ((...args: ["block" | "microblock"] | ["block" | "microblock", Omit<{
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => number)

Type declaration

- (...args: ["block" | "microblock"] | ["block" | "microblock", Omit<{
      _expectedMineRate?: number;
      _maxPollInterval?: number;
      _microBlockCycle?: number;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): number
- Parameters
  - Rest ...args: ["block" | "microblock"] | ["block" | "microblock", Omit<{
        _expectedMineRate?: number;
        _maxPollInterval?: number;
        _microBlockCycle?: number;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns number

_options

_options: AeSdkMethodsOptions = ...

accounts

accounts: {
[key: AccountAddress]: AccountBase;
} = {}

Type declaration

[key: AccountAddress]: AccountBase

aensBid

aensBid: ((...args: [name: `${string}.chain`, nameFee: string | number | BigNumber] | [`${string}.chain`, string | number | BigNumber, Omit<Omit<AensClaimOptions, "nameFee">, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<AensClaimReturnType>)

Type declaration

- (...args: [name: `${string}.chain`, nameFee: string | number | BigNumber] | [`${string}.chain`, string | number | BigNumber, Omit<Omit<AensClaimOptions, "nameFee">, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<AensClaimReturnType>
- Parameters
  - Rest ...args: [name: `${string}.chain`, nameFee: string | number | BigNumber] | [`${string}.chain`, string | number | BigNumber, Omit<Omit<AensClaimOptions, "nameFee">, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<AensClaimReturnType>

aensClaim

aensClaim: ((...args: [name: `${string}.chain`, salt: number] | [`${string}.chain`, number, Omit<AensClaimOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<AensClaimReturnType>)

Type declaration

- (...args: [name: `${string}.chain`, salt: number] | [`${string}.chain`, number, Omit<AensClaimOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<AensClaimReturnType>
- Parameters
  - Rest ...args: [name: `${string}.chain`, salt: number] | [`${string}.chain`, number, Omit<AensClaimOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<AensClaimReturnType>

aensPreclaim

aensPreclaim: ((...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensPreclaimOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<Readonly<SendReturnType & {
    claim: ((opts?: AensClaimOptions) => Promise<AensClaimReturnType>);
    commitmentId: string;
    height: number;
    salt: number;
}>>)

Type declaration

- (...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensPreclaimOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<Readonly<SendReturnType & {
      claim: ((opts?: AensClaimOptions) => Promise<AensClaimReturnType>);
      commitmentId: string;
      height: number;
      salt: number;
  }>>
- Parameters
  - Rest ...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensPreclaimOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<Readonly<SendReturnType & {
      claim: ((opts?: AensClaimOptions) => Promise<AensClaimReturnType>);
      commitmentId: string;
      height: number;
      salt: number;
  }>>

aensQuery

aensQuery: ((...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<{
    onNode: Node;
} & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<Readonly<{
    id: string;
    owner?: string;
    pointers: ({ key: string; id: string; })[];
    ttl: number;
} & {
    extendTtl: ((nameTtl: number, options?: Omit<{
        onNode: Node;
    } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler">) => Promise<SendReturnType> & Promise<Readonly<{
        id: string;
        owner?: string;
        pointers: ({ key: string; id: string; })[];
        ttl: number;
    } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
    id: `nm_${string}`;
    owner: `ak_${string}`;
    pointers: NamePointer[] | KeyPointers;
    revoke: ((options?: Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: AccountBase;
    }) => Promise<SendReturnType>);
    transfer: ((account: `ak_${string}`, options?: {
        onNode: Node;
    } & AensUpdateOptions & AensTransferOptions) => Promise<SendReturnType> & Promise<Readonly<{
        id: string;
        owner?: string;
        pointers: ({ key: string; id: string; })[];
        ttl: number;
    } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
    ttl: number;
    update: ((pointers: KeyPointers, options?: Omit<{
        onNode: Node;
    } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: AccountBase;
    }) => Promise<SendReturnType> & Promise<Readonly<{
        id: string;
        owner?: string;
        pointers: ({ key: string; id: string; })[];
        ttl: number;
    } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
}>>)

Type declaration

- (...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<{
      onNode: Node;
  } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<Readonly<{
      id: string;
      owner?: string;
      pointers: ({ key: string; id: string; })[];
      ttl: number;
  } & {
      extendTtl: ((nameTtl: number, options?: Omit<{
          onNode: Node;
      } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler">) => Promise<SendReturnType> & Promise<Readonly<{
          id: string;
          owner?: string;
          pointers: ({ key: string; id: string; })[];
          ttl: number;
      } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
      id: `nm_${string}`;
      owner: `ak_${string}`;
      pointers: NamePointer[] | KeyPointers;
      revoke: ((options?: Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: AccountBase;
      }) => Promise<SendReturnType>);
      transfer: ((account: `ak_${string}`, options?: {
          onNode: Node;
      } & AensUpdateOptions & AensTransferOptions) => Promise<SendReturnType> & Promise<Readonly<{
          id: string;
          owner?: string;
          pointers: ({ key: string; id: string; })[];
          ttl: number;
      } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
      ttl: number;
      update: ((pointers: KeyPointers, options?: Omit<{
          onNode: Node;
      } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: AccountBase;
      }) => Promise<SendReturnType> & Promise<Readonly<{
          id: string;
          owner?: string;
          pointers: ({ key: string; id: string; })[];
          ttl: number;
      } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
  }>>
- Parameters
  - Rest ...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<{
        onNode: Node;
    } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<Readonly<{
      id: string;
      owner?: string;
      pointers: ({ key: string; id: string; })[];
      ttl: number;
  } & {
      extendTtl: ((nameTtl: number, options?: Omit<{
          onNode: Node;
      } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler">) => Promise<SendReturnType> & Promise<Readonly<{
          id: string;
          owner?: string;
          pointers: ({ key: string; id: string; })[];
          ttl: number;
      } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
      id: `nm_${string}`;
      owner: `ak_${string}`;
      pointers: NamePointer[] | KeyPointers;
      revoke: ((options?: Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: AccountBase;
      }) => Promise<SendReturnType>);
      transfer: ((account: `ak_${string}`, options?: {
          onNode: Node;
      } & AensUpdateOptions & AensTransferOptions) => Promise<SendReturnType> & Promise<Readonly<{
          id: string;
          owner?: string;
          pointers: ({ key: string; id: string; })[];
          ttl: number;
      } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
      ttl: number;
      update: ((pointers: KeyPointers, options?: Omit<{
          onNode: Node;
      } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: AccountBase;
      }) => Promise<SendReturnType> & Promise<Readonly<{
          id: string;
          owner?: string;
          pointers: ({ key: string; id: string; })[];
          ttl: number;
      } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
  }>>

aensRevoke

aensRevoke: ((...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

- (...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendReturnType>
- Parameters
  - Rest ...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendReturnType>

aensTransfer

aensTransfer: ((...args: [name: `${string}.chain`, account: `ak_${string}`] | [`${string}.chain`, `ak_${string}`, Omit<AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

- (...args: [name: `${string}.chain`, account: `ak_${string}`] | [`${string}.chain`, `ak_${string}`, Omit<AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendReturnType>
- Parameters
  - Rest ...args: [name: `${string}.chain`, account: `ak_${string}`] | [`${string}.chain`, `ak_${string}`, Omit<AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendReturnType>

aensUpdate

aensUpdate: ((...args: [`${string}.chain`, KeyPointers] | [`${string}.chain`, KeyPointers, Omit<AensUpdateOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

- (...args: [`${string}.chain`, KeyPointers] | [`${string}.chain`, KeyPointers, Omit<AensUpdateOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendReturnType>
- Parameters
  - Rest ...args: [`${string}.chain`, KeyPointers] | [`${string}.chain`, KeyPointers, Omit<AensUpdateOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendReturnType>

awaitHeight

awaitHeight: ((...args: [number] | [number, Omit<{
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<number>)

Type declaration

- (...args: [number] | [number, Omit<{
      interval?: number;
      onNode: Node;
  } & {
      _expectedMineRate?: number;
      _maxPollInterval?: number;
      _microBlockCycle?: number;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<number>
- Parameters
  - Rest ...args: [number] | [number, Omit<{
        interval?: number;
        onNode: Node;
    } & {
        _expectedMineRate?: number;
        _maxPollInterval?: number;
        _microBlockCycle?: number;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<number>

buildAuthTxHash

buildAuthTxHash: ((...args: [`tx_${string}`] | [`tx_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<Uint8Array>)

Type declaration

- (...args: [`tx_${string}`] | [`tx_${string}`, Omit<{
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<Uint8Array>
- Parameters
  - Rest ...args: [`tx_${string}`] | [`tx_${string}`, Omit<{
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<Uint8Array>

createGeneralizedAccount

createGeneralizedAccount: ((...args: [string, any[]] | [string, any[], Omit<CreateGeneralizedAccountOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<Readonly<{
    gaContractId: `ct_${string}`;
    owner: `ak_${string}`;
    rawTx: `tx_${string}`;
    transaction: `th_${string}`;
}>>)

Type declaration

- (...args: [string, any[]] | [string, any[], Omit<CreateGeneralizedAccountOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<Readonly<{
      gaContractId: `ct_${string}`;
      owner: `ak_${string}`;
      rawTx: `tx_${string}`;
      transaction: `th_${string}`;
  }>>
- Parameters
  - Rest ...args: [string, any[]] | [string, any[], Omit<CreateGeneralizedAccountOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<Readonly<{
      gaContractId: `ct_${string}`;
      owner: `ak_${string}`;
      rawTx: `tx_${string}`;
      transaction: `th_${string}`;
  }>>

extendOracleTtl

extendOracleTtl: ((...args: [oracleId: `ok_${string}`] | [`ok_${string}`, Omit<ExtendOracleTtlOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType & GetOracleObjectReturnType>)

Type declaration

- (...args: [oracleId: `ok_${string}`] | [`ok_${string}`, Omit<ExtendOracleTtlOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendReturnType & GetOracleObjectReturnType>
- Parameters
  - Rest ...args: [oracleId: `ok_${string}`] | [`ok_${string}`, Omit<ExtendOracleTtlOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendReturnType & GetOracleObjectReturnType>

getAccount

getAccount: ((...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
    hash?: `kh_${string}` | `mh_${string}`;
    height?: number;
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    authFun?: string;
    balance: bigint;
    contractId?: string;
    id: string;
    kind?: AccountKind;
    nonce: number;
    payable?: boolean;
}>)

Type declaration

- (...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
      hash?: `kh_${string}` | `mh_${string}`;
      height?: number;
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<{
      authFun?: string;
      balance: bigint;
      contractId?: string;
      id: string;
      kind?: AccountKind;
      nonce: number;
      payable?: boolean;
  }>
- Parameters
  - Rest ...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
        hash?: `kh_${string}` | `mh_${string}`;
        height?: number;
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<{
      authFun?: string;
      balance: bigint;
      contractId?: string;
      id: string;
      kind?: AccountKind;
      nonce: number;
      payable?: boolean;
  }>

getBalance

getBalance: ((...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
    format?: AE_AMOUNT_FORMATS;
} & {
    hash?: `kh_${string}` | `mh_${string}`;
    height?: number;
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<string>)

Type declaration

- (...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
      format?: AE_AMOUNT_FORMATS;
  } & {
      hash?: `kh_${string}` | `mh_${string}`;
      height?: number;
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<string>
- Parameters
  - Rest ...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
        format?: AE_AMOUNT_FORMATS;
    } & {
        hash?: `kh_${string}` | `mh_${string}`;
        height?: number;
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<string>

getContract

getContract: ((...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    abiVersion: string;
    active: boolean;
    deposit: bigint;
    id: string;
    ownerId: string;
    referrerIds: string[];
    vmVersion: string;
}>)

Type declaration

- (...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<{
      abiVersion: string;
      active: boolean;
      deposit: bigint;
      id: string;
      ownerId: string;
      referrerIds: string[];
      vmVersion: string;
  }>
- Parameters
  - Rest ...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<{
      abiVersion: string;
      active: boolean;
      deposit: bigint;
      id: string;
      ownerId: string;
      referrerIds: string[];
      vmVersion: string;
  }>

getContractByteCode

getContractByteCode: ((...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    bytecode: `cb_${string}`;
}>)

Type declaration

- (...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<{
      bytecode: `cb_${string}`;
  }>
- Parameters
  - Rest ...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<{
  bytecode: `cb_${string}`;
  }>

getCurrentGeneration

getCurrentGeneration: ((...args: [] | [Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
    microBlocks: string[];
}>)

Type declaration

- (...args: [] | [Omit<{
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<{
      keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
      microBlocks: string[];
  }>
- Parameters
  - Rest ...args: [] | [Omit<{
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<{
  keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
  microBlocks: string[];
  }>

getGeneration

getGeneration: ((...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
    microBlocks: string[];
}>)

Type declaration

- (...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<{
      keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
      microBlocks: string[];
  }>
- Parameters
  - Rest ...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<{
  keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
  microBlocks: string[];
  }>

getHeight

getHeight: ((...args: [] | [Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<number>)

Type declaration

- (...args: [] | [Omit<{
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<number>
- Parameters
  - Rest ...args: [] | [Omit<{
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<number>

getKeyBlock

getKeyBlock: ((...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    beneficiary: string;
    hash: string;
    height: number;
    info: string;
    miner: string;
    nonce?: number;
    pow?: string[];
    prevHash: string;
    prevKeyHash: string;
    stateHash: string;
    target: string;
    time: number;
    version: number;
}>)

Type declaration

- (...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<{
      beneficiary: string;
      hash: string;
      height: number;
      info: string;
      miner: string;
      nonce?: number;
      pow?: string[];
      prevHash: string;
      prevKeyHash: string;
      stateHash: string;
      target: string;
      time: number;
      version: number;
  }>
- Parameters
  - Rest ...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<{
      beneficiary: string;
      hash: string;
      height: number;
      info: string;
      miner: string;
      nonce?: number;
      pow?: string[];
      prevHash: string;
      prevKeyHash: string;
      stateHash: string;
      target: string;
      time: number;
      version: number;
  }>

getMicroBlockHeader

getMicroBlockHeader: ((...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    hash: string;
    height: number;
    pofHash: string;
    prevHash: string;
    prevKeyHash: string;
    signature: string;
    stateHash: string;
    time: number;
    txsHash: string;
    version: number;
}>)

Type declaration

- (...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<{
      hash: string;
      height: number;
      pofHash: string;
      prevHash: string;
      prevKeyHash: string;
      signature: string;
      stateHash: string;
      time: number;
      txsHash: string;
      version: number;
  }>
- Parameters
  - Rest ...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<{
      hash: string;
      height: number;
      pofHash: string;
      prevHash: string;
      prevKeyHash: string;
      signature: string;
      stateHash: string;
      time: number;
      txsHash: string;
      version: number;
  }>

getMicroBlockTransactions

getMicroBlockTransactions: ((...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    blockHash: string;
    blockHeight: number;
    hash: string;
    signatures: string[];
    tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
}[]>)

Type declaration

- (...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<{
      blockHash: string;
      blockHeight: number;
      hash: string;
      signatures: string[];
      tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
  }[]>
- Parameters
  - Rest ...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<{
      blockHash: string;
      blockHeight: number;
      hash: string;
      signatures: string[];
      tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
  }[]>

getName

getName: ((...args: [`${string}.chain`] | [`${string}.chain`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    id: string;
    owner?: string;
    pointers: ({ key: string; id: string; })[];
    ttl: number;
}>)

Type declaration

- (...args: [`${string}.chain`] | [`${string}.chain`, Omit<{
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<{
      id: string;
      owner?: string;
      pointers: ({ key: string; id: string; })[];
      ttl: number;
  }>
- Parameters
  - Rest ...args: [`${string}.chain`] | [`${string}.chain`, Omit<{
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<{
      id: string;
      owner?: string;
      pointers: ({ key: string; id: string; })[];
      ttl: number;
  }>

getOracleObject

getOracleObject: ((...args: [oracleId: `ok_${string}`] | [`ok_${string}`, Omit<{
    onAccount: AccountBase;
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<GetOracleObjectReturnType>)

Type declaration

- (...args: [oracleId: `ok_${string}`] | [`ok_${string}`, Omit<{
      onAccount: AccountBase;
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<GetOracleObjectReturnType>
- Parameters
  - Rest ...args: [oracleId: `ok_${string}`] | [`ok_${string}`, Omit<{
        onAccount: AccountBase;
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<GetOracleObjectReturnType>

getQueryObject

getQueryObject: ((...args: [oracleId: `ok_${string}`, queryId: `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<RespondToQueryOptions & {
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<GetQueryObjectReturnType>)

Type declaration

- (...args: [oracleId: `ok_${string}`, queryId: `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<RespondToQueryOptions & {
      interval?: number;
      onNode: Node;
  } & {
      _expectedMineRate?: number;
      _maxPollInterval?: number;
      _microBlockCycle?: number;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<GetQueryObjectReturnType>
- Parameters
  - Rest ...args: [oracleId: `ok_${string}`, queryId: `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<RespondToQueryOptions & {
        interval?: number;
        onNode: Node;
    } & {
        _expectedMineRate?: number;
        _maxPollInterval?: number;
        _microBlockCycle?: number;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<GetQueryObjectReturnType>

payForTransaction

payForTransaction: ((...args: [transaction: `tx_${string}`] | [`tx_${string}`, Omit<PayForTransactionOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

- (...args: [transaction: `tx_${string}`] | [`tx_${string}`, Omit<PayForTransactionOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendReturnType>
- Parameters
  - Rest ...args: [transaction: `tx_${string}`] | [`tx_${string}`, Omit<PayForTransactionOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendReturnType>

poll

poll: ((...args: [`th_${string}`] | [`th_${string}`, Omit<{
    blocks?: number;
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    blockHash: string;
    blockHeight: number;
    hash: string;
    signatures: string[];
    tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
}>)

Type declaration

- (...args: [`th_${string}`] | [`th_${string}`, Omit<{
      blocks?: number;
      interval?: number;
      onNode: Node;
  } & {
      _expectedMineRate?: number;
      _maxPollInterval?: number;
      _microBlockCycle?: number;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<{
      blockHash: string;
      blockHeight: number;
      hash: string;
      signatures: string[];
      tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
  }>
- Parameters
  - Rest ...args: [`th_${string}`] | [`th_${string}`, Omit<{
        blocks?: number;
        interval?: number;
        onNode: Node;
    } & {
        _expectedMineRate?: number;
        _maxPollInterval?: number;
        _microBlockCycle?: number;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<{
      blockHash: string;
      blockHeight: number;
      hash: string;
      signatures: string[];
      tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
  }>

pollForQueries

pollForQueries: ((...args: [`ok_${string}`, ((queries: {
    fee: bigint;
    id: string;
    oracleId: string;
    query: string;
    response: string;
    responseTtl: { type: TTLType; value: string; };
    senderId: string;
    senderNonce: string;
    ttl: number;
}[]) => void)] | [`ok_${string}`, ((queries: {
    fee: bigint;
    id: string;
    oracleId: string;
    query: string;
    response: string;
    responseTtl: { type: TTLType; value: string; };
    senderId: string;
    senderNonce: string;
    ttl: number;
}[]) => void), Omit<{
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => (() => void))

Type declaration

- (...args: [`ok_${string}`, ((queries: {
      fee: bigint;
      id: string;
      oracleId: string;
      query: string;
      response: string;
      responseTtl: { type: TTLType; value: string; };
      senderId: string;
      senderNonce: string;
      ttl: number;
  }[]) => void)] | [`ok_${string}`, ((queries: {
      fee: bigint;
      id: string;
      oracleId: string;
      query: string;
      response: string;
      responseTtl: { type: TTLType; value: string; };
      senderId: string;
      senderNonce: string;
      ttl: number;
  }[]) => void), Omit<{
      interval?: number;
      onNode: Node;
  } & {
      _expectedMineRate?: number;
      _maxPollInterval?: number;
      _microBlockCycle?: number;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): (() => void)
- Parameters
  - Rest ...args: [`ok_${string}`, ((queries: {
        fee: bigint;
        id: string;
        oracleId: string;
        query: string;
        response: string;
        responseTtl: { type: TTLType; value: string; };
        senderId: string;
        senderNonce: string;
        ttl: number;
    }[]) => void)] | [`ok_${string}`, ((queries: {
        fee: bigint;
        id: string;
        oracleId: string;
        query: string;
        response: string;
        responseTtl: { type: TTLType; value: string; };
        senderId: string;
        senderNonce: string;
        ttl: number;
    }[]) => void), Omit<{
        interval?: number;
        onNode: Node;
    } & {
        _expectedMineRate?: number;
        _maxPollInterval?: number;
        _microBlockCycle?: number;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns (() => void)
  - - (): void
    - Poll for oracle queries
      
      Category
      oracle
      
      Returns
      Callback to stop polling function
      
      Returns void

pollForQueryResponse

pollForQueryResponse: ((...args: [`ok_${string}`, `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<{
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<string>)

Type declaration

- (...args: [`ok_${string}`, `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<{
      interval?: number;
      onNode: Node;
  } & {
      _expectedMineRate?: number;
      _maxPollInterval?: number;
      _microBlockCycle?: number;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<string>
- Parameters
  - Rest ...args: [`ok_${string}`, `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<{
        interval?: number;
        onNode: Node;
    } & {
        _expectedMineRate?: number;
        _maxPollInterval?: number;
        _microBlockCycle?: number;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<string>

pool

pool: Map<string, Node> = ...

postQueryToOracle

postQueryToOracle: ((...args: [oracleId: `ok_${string}`, query: string] | [`ok_${string}`, string, Omit<PostQueryToOracleOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType & GetQueryObjectReturnType>)

Type declaration

- (...args: [oracleId: `ok_${string}`, query: string] | [`ok_${string}`, string, Omit<PostQueryToOracleOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendReturnType & GetQueryObjectReturnType>
- Parameters
  - Rest ...args: [oracleId: `ok_${string}`, query: string] | [`ok_${string}`, string, Omit<PostQueryToOracleOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendReturnType & GetQueryObjectReturnType>

registerOracle

registerOracle: ((...args: [queryFormat: string, responseFormat: string] | [string, string, Omit<RegisterOracleOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType & GetOracleObjectReturnType>)

Type declaration

- (...args: [queryFormat: string, responseFormat: string] | [string, string, Omit<RegisterOracleOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendReturnType & GetOracleObjectReturnType>
- Parameters
  - Rest ...args: [queryFormat: string, responseFormat: string] | [string, string, Omit<RegisterOracleOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendReturnType & GetOracleObjectReturnType>

resolveName

resolveName: ((...args: [`${string}.chain` | `ct_${string}` | `ak_${string}`, string] | [`${string}.chain` | `ct_${string}` | `ak_${string}`, string, Omit<{
    onNode: Node;
    resolveByNode?: boolean;
    verify?: boolean;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<`ct_${string}` | `ak_${string}` | `nm_${string}`>)

Type declaration

- (...args: [`${string}.chain` | `ct_${string}` | `ak_${string}`, string] | [`${string}.chain` | `ct_${string}` | `ak_${string}`, string, Omit<{
      onNode: Node;
      resolveByNode?: boolean;
      verify?: boolean;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<`ct_${string}` | `ak_${string}` | `nm_${string}`>
- Parameters
  - Rest ...args: [`${string}.chain` | `ct_${string}` | `ak_${string}`, string] | [`${string}.chain` | `ct_${string}` | `ak_${string}`, string, Omit<{
        onNode: Node;
        resolveByNode?: boolean;
        verify?: boolean;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<`ct_${string}` | `ak_${string}` | `nm_${string}`>

respondToQuery

respondToQuery: ((...args: [oracleId: `ok_${string}`, queryId: `oq_${string}`, response: string] | [`ok_${string}`, `oq_${string}`, string, Omit<RespondToQueryOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType & GetOracleObjectReturnType>)

Type declaration

- (...args: [oracleId: `ok_${string}`, queryId: `oq_${string}`, response: string] | [`ok_${string}`, `oq_${string}`, string, Omit<RespondToQueryOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendReturnType & GetOracleObjectReturnType>
- Parameters
  - Rest ...args: [oracleId: `ok_${string}`, queryId: `oq_${string}`, response: string] | [`ok_${string}`, `oq_${string}`, string, Omit<RespondToQueryOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendReturnType & GetOracleObjectReturnType>

`Optional` selectedAddress

selectedAddress?: `ak_${string}`

`Optional` selectedNodeName

selectedNodeName?: string

send

send: ((...args: [tx: `tx_${string}`] | [`tx_${string}`, Omit<SendOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

- (...args: [tx: `tx_${string}`] | [`tx_${string}`, Omit<SendOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendReturnType>
- Parameters
  - Rest ...args: [tx: `tx_${string}`] | [`tx_${string}`, Omit<SendOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendReturnType>

sendTransaction

sendTransaction: ((...args: [`tx_${string}`] | [`tx_${string}`, Omit<SendTransactionOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendTransactionReturnType>)

Type declaration

- (...args: [`tx_${string}`] | [`tx_${string}`, Omit<SendTransactionOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendTransactionReturnType>
- Parameters
  - Rest ...args: [`tx_${string}`] | [`tx_${string}`, Omit<SendTransactionOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendTransactionReturnType>

spend

spend: ((...args: [amount: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<SpendOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

- (...args: [amount: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<SpendOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendReturnType>
- Parameters
  - Rest ...args: [amount: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<SpendOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendReturnType>

transferFunds

transferFunds: ((...args: [fraction: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<TransferFundsOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

- (...args: [fraction: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<TransferFundsOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendReturnType>
- Parameters
  - Rest ...args: [fraction: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<TransferFundsOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendReturnType>

txDryRun

txDryRun: ((...args: [`tx_${string}`, `ak_${string}`] | [`tx_${string}`, `ak_${string}`, Omit<{
    combine?: boolean;
    onNode: Node;
    top?: number | `kh_${string}` | `mh_${string}`;
    txEvents?: boolean;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    txEvents?: {}[];
} & {
    callObj?: { callerId: string; callerNonce: string; height: number; contractId: string; gasPrice: bigint; gasUsed: number; log: { address: string; topics: string[]; data: string; }[]; returnValue: string; returnType: ContractCallReturnType; };
    reason?: string;
    result: string;
    type: string;
}>)

Type declaration

- (...args: [`tx_${string}`, `ak_${string}`] | [`tx_${string}`, `ak_${string}`, Omit<{
      combine?: boolean;
      onNode: Node;
      top?: number | `kh_${string}` | `mh_${string}`;
      txEvents?: boolean;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<{
      txEvents?: {}[];
  } & {
      callObj?: { callerId: string; callerNonce: string; height: number; contractId: string; gasPrice: bigint; gasUsed: number; log: { address: string; topics: string[]; data: string; }[]; returnValue: string; returnType: ContractCallReturnType; };
      reason?: string;
      result: string;
      type: string;
  }>
- Parameters
  - Rest ...args: [`tx_${string}`, `ak_${string}`] | [`tx_${string}`, `ak_${string}`, Omit<{
        combine?: boolean;
        onNode: Node;
        top?: number | `kh_${string}` | `mh_${string}`;
        txEvents?: boolean;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<{
      txEvents?: {}[];
  } & {
      callObj?: { callerId: string; callerNonce: string; height: number; contractId: string; gasPrice: bigint; gasUsed: number; log: { address: string; topics: string[]; data: string; }[]; returnValue: string; returnType: ContractCallReturnType; };
      reason?: string;
      result: string;
      type: string;
  }>

waitForTxConfirm

waitForTxConfirm: ((...args: [`th_${string}`] | [`th_${string}`, Omit<{
    confirm?: number;
    onNode: Node;
} & {
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<number>)

Type declaration

- (...args: [`th_${string}`] | [`th_${string}`, Omit<{
      confirm?: number;
      onNode: Node;
  } & {
      interval?: number;
      onNode: Node;
  } & {
      _expectedMineRate?: number;
      _maxPollInterval?: number;
      _microBlockCycle?: number;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<number>
- Parameters
  - Rest ...args: [`th_${string}`] | [`th_${string}`, Omit<{
        confirm?: number;
        onNode: Node;
    } & {
        interval?: number;
        onNode: Node;
    } & {
        _expectedMineRate?: number;
        _maxPollInterval?: number;
        _microBlockCycle?: number;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<number>

Accessors

address

get address(): `ak_${string}`
Returns `ak_${string}`
Inherited from AeSdkBase.address
- Defined in AeSdkBase.ts:130

api

get api(): Node
Returns Node
Inherited from AeSdkBase.api
- Defined in AeSdkBase.ts:45

compilerApi

get compilerApi(): CompilerBase
Returns CompilerBase
Inherited from AeSdkBase.compilerApi
- Defined in AeSdkBase.ts:38

Methods

_getOptions

_getOptions(): {
    onAccount: AccountBase;
    onCompiler: CompilerBase;
    onNode: Node;
}
Returns {
    onAccount: AccountBase;
    onCompiler: CompilerBase;
    onNode: Node;
}
- onAccount: AccountBase
- onCompiler: CompilerBase
- onNode: Node
Inherited from AeSdkBase._getOptions
- Defined in AeSdkBase.ts:156

_resolveAccount

_resolveAccount(account?: OnAccount): AccountBase
Resolves an account
Parameters
- account: OnAccount = ...
  
  ak-address, instance of AccountBase, or keypair
Returns AccountBase
Overrides AeSdkBase._resolveAccount
- Defined in AeSdk.ts:20

addAccount

addAccount(account: AccountBase, options?: {
select?: boolean;
}): void
Add specific account

Example
```
addAccount(account)
```
Parameters
- account: AccountBase
  
  Account instance
- options: {
  select?: boolean;
  } = {}
  
  Options
  - Optional select?: boolean
    
    Select account
Returns void
- Defined in AeSdk.ts:45

addNode

addNode(name: string, node: Node, select?: boolean): void
Add Node

Example
```
// add and select new node with name 'testNode'
aeSdkBase.addNode('testNode', new Node({ url }), true)
```
Parameters
- name: string
  
  Node name
- node: Node
  
  Node instance
- select: boolean = false
  
  Select this node as current
Returns void
Inherited from AeSdkBase.addNode
- Defined in AeSdkBase.ts:61

addresses

addresses(): `ak_${string}`[]
Get accounts addresses

Example
```
addresses()
```
Returns `ak_${string}`[]
Overrides AeSdkBase.addresses
- Defined in AeSdk.ts:34

buildTx

buildTx<TxType>(txType: TxType, options: Omit<Omit<{
    tag: TxType;
    version?: Extract<KeysOfUnion<{
        10: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => Account);
                serialize: ((value?: Account) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["balance", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }]];
            2: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => Account);
                serialize: ((value?: Account) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 2);
                serialize: ((value?: 2) => Buffer);
            }], readonly ["flags", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["balance", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["gaContract", {
                deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
                serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
            }], readonly ["gaAuthFun", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `cb_${string}`) => Buffer);
            }]];
        };
        11: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => SignedTx);
                serialize: ((value?: SignedTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["signatures", {
                deserialize: ((value: Buffer[], params: unknown) => Buffer[]);
                serialize: ((value: Uint8Array[], params: unknown) => Buffer[]);
            }], readonly ["encodedTx", {
                deserialize: ((value: Buffer, options: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }) => any);
                serialize: ((value: any, options: {
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                }) => Buffer);
            }]];
        };
        12: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => SpendTx);
                serialize: ((value?: SpendTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["senderId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["recipientId", {
                deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
                serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
            }], readonly ["amount", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value: undefined | string): string;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["payload", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value?: `ba_${string}`) => Buffer);
            }]];
        };
        20: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => Oracle);
                serialize: ((value?: Oracle) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["accountId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["queryFormat", {
                deserialize(buffer: Buffer): string;
                serialize(string: string): Buffer;
            }], readonly ["responseFormat", {
                deserialize(buffer: Buffer): string;
                serialize(string: string): Buffer;
            }], readonly ["queryFee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value: undefined | string): string;
            }], readonly ["oracleTtlValue", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["abiVersion", {
                deserialize(buffer: Buffer): AbiVersion;
                serialize(value: undefined | AbiVersion, __namedParameters: {
                    consensusProtocolVersion: Iris;
                    tag: Tag;
                }): Buffer;
            }]];
        };
        22: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => OracleRegisterTx);
                serialize: ((value?: OracleRegisterTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["accountId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["queryFormat", {
                deserialize(buffer: Buffer): string;
                serialize(string: string): Buffer;
            }], readonly ["responseFormat", {
                deserialize(buffer: Buffer): string;
                serialize(string: string): Buffer;
            }], readonly ["queryFee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value: undefined | string): string;
            }], readonly ["oracleTtlType", {
                deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
            }], readonly ["oracleTtlValue", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["abiVersion", {
                deserialize(buffer: Buffer): AbiVersion;
                serialize(value: undefined | AbiVersion, __namedParameters: {
                    consensusProtocolVersion: Iris;
                    tag: Tag;
                }): Buffer;
            }]];
        };
        23: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => OracleQueryTx);
                serialize: ((value?: OracleQueryTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["senderId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["oracleId", {
                deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
                serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
            }], readonly ["query", {
                deserialize(buffer: Buffer): string;
                serialize(string: string): Buffer;
            }], readonly ["queryFee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value: undefined | string): string;
            }], readonly ["queryTtlType", {
                deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
            }], readonly ["queryTtlValue", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["responseTtlType", {
                deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
            }], readonly ["responseTtlValue", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        24: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => OracleResponseTx);
                serialize: ((value?: OracleResponseTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["oracleId", {
                deserialize: ((value: Buffer) => `ok_${string}`);
                serialize: ((value: `ok_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["queryId", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `oq_${string}`) => Buffer);
            }], readonly ["response", {
                deserialize(buffer: Buffer): string;
                serialize(string: string): Buffer;
            }], readonly ["responseTtlType", {
                deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
            }], readonly ["responseTtlValue", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        25: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => OracleExtendTx);
                serialize: ((value?: OracleExtendTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["oracleId", {
                deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
                serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["oracleTtlType", {
                deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
            }], readonly ["oracleTtlValue", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        30: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => Name);
                serialize: ((value?: Name) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["accountId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nameTtl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["status", {
                deserialize(buffer: Buffer): Buffer;
                serialize(buffer: Uint8Array): Buffer;
            }], readonly ["clientTtl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["pointers", {
                deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
                serialize(pointers: NamePointer[]): Buffer[][];
            }]];
        };
        32: {
            2: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => NameClaimTx);
                serialize: ((value?: NameClaimTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 2);
                serialize: ((value?: 2) => Buffer);
            }], readonly ["accountId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["name", {
                deserialize(value: Buffer): `${string}.chain`;
                serialize(value: `${string}.chain`): Buffer;
            }], readonly ["nameSalt", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["nameFee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, txFields: {
                    name: `${string}.chain`;
                } & Options): Buffer;
                serializeAettos(_value: undefined | string, txFields: {
                    name: `${string}.chain`;
                }): string;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        33: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => NamePreclaimTx);
                serialize: ((value?: NamePreclaimTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["accountId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["commitmentId", {
                deserialize: ((value: Buffer) => `cm_${string}`);
                serialize: ((value: `cm_${string}`) => Buffer);
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        34: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => NameUpdateTx);
                serialize: ((value?: NameUpdateTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["accountId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["nameId", {
                deserialize: ((value: Buffer) => `nm_${string}`);
                serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
            }], readonly ["nameTtl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["pointers", {
                deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
                serialize(pointers: NamePointer[]): Buffer[][];
            }], readonly ["clientTtl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        35: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => NameRevokeTx);
                serialize: ((value?: NameRevokeTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["accountId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["nameId", {
                deserialize: ((value: Buffer) => `nm_${string}`);
                serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        36: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => NameTransferTx);
                serialize: ((value?: NameTransferTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["accountId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["nameId", {
                deserialize: ((value: Buffer) => `nm_${string}`);
                serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
            }], readonly ["recipientId", {
                deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
                serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        40: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => Contract);
                serialize: ((value?: Contract) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["owner", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["ctVersion", {
                deserialize(buffer: Buffer): CtVersion;
                serialize(value: undefined | CtVersion, __namedParameters: {
                    consensusProtocolVersion: Iris;
                }): Buffer;
            }], readonly ["code", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `cb_${string}`) => Buffer);
            }], readonly ["log", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `cb_${string}`) => Buffer);
            }], readonly ["active", {
                deserialize(buffer: Buffer): boolean;
                serialize(value: boolean): Buffer;
            }], readonly ["referers", {
                deserialize: ((value: Buffer[], params: unknown) => `ak_${string}`[]);
                serialize: ((value: `ak_${string}`[], params: unknown) => Buffer[]);
            }], readonly ["deposit", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, options: Options): Buffer;
                serializeAettos(value: undefined | string): string;
            }]];
        };
        41: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ContractCall);
                serialize: ((value?: ContractCall) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["callerId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["callerNonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["height", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["contractId", {
                deserialize: ((value: Buffer) => `ct_${string}`);
                serialize: ((value: `ct_${string}`) => Buffer);
            }], readonly ["gasPrice", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value?: undefined | string): string;
            }], readonly ["gasUsed", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["returnValue", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `cb_${string}`) => Buffer);
            }], readonly ["returnType", {
                deserialize: ((value: Buffer) => CallReturnType);
                serialize: ((value: CallReturnType) => Buffer);
            }], readonly ["log", {
                deserialize(buffer: Buffer): Buffer;
                serialize(buffer: Uint8Array): Buffer;
            }]];
        };
        42: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ContractCreateTx);
                serialize: ((value?: ContractCreateTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["ownerId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["code", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `cb_${string}`) => Buffer);
            }], readonly ["ctVersion", {
                deserialize(buffer: Buffer): CtVersion;
                serialize(value: undefined | CtVersion, __namedParameters: {
                    consensusProtocolVersion: Iris;
                }): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["deposit", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, options: Options): Buffer;
                serializeAettos(value: undefined | string): string;
            }], readonly ["amount", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value: undefined | string): string;
            }], readonly ["gasLimit", {
                deserialize(value: Buffer): number;
                serialize(_value: undefined | number, __namedParameters: {
                    _computingGasLimit?: number;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    gasMax: number;
                    rebuildTx: ((params: any) => any);
                    tag: Tag;
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): Buffer;
            }], readonly ["gasPrice", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value?: undefined | string): string;
            }], readonly ["callData", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `cb_${string}`) => Buffer);
            }]];
        };
        43: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ContractCallTx);
                serialize: ((value?: ContractCallTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["callerId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["contractId", {
                deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
                serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
            }], readonly ["abiVersion", {
                deserialize(buffer: Buffer): AbiVersion;
                serialize(value: undefined | AbiVersion, __namedParameters: {
                    consensusProtocolVersion: Iris;
                    tag: Tag;
                }): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["amount", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value: undefined | string): string;
            }], readonly ["gasLimit", {
                deserialize(value: Buffer): number;
                serialize(_value: undefined | number, __namedParameters: {
                    _computingGasLimit?: number;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    gasMax: number;
                    rebuildTx: ((params: any) => any);
                    tag: Tag;
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): Buffer;
            }], readonly ["gasPrice", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value?: undefined | string): string;
            }], readonly ["callData", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `cb_${string}`) => Buffer);
            }]];
        };
        50: {
            2: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelCreateTx);
                serialize: ((value?: ChannelCreateTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 2);
                serialize: ((value?: 2) => Buffer);
            }], readonly ["initiator", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["initiatorAmount", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["responder", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["responderAmount", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["channelReserve", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["lockPeriod", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["initiatorDelegateIds", {
                deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
            }], readonly ["responderDelegateIds", {
                deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
            }], readonly ["stateHash", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `st_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        51: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelDepositTx);
                serialize: ((value?: ChannelDepositTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["channelId", {
                deserialize: ((value: Buffer) => `ch_${string}`);
                serialize: ((value: `ch_${string}`) => Buffer);
            }], readonly ["fromId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["amount", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["stateHash", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `st_${string}`) => Buffer);
            }], readonly ["round", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        52: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelWithdrawTx);
                serialize: ((value?: ChannelWithdrawTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["channelId", {
                deserialize: ((value: Buffer) => `ch_${string}`);
                serialize: ((value: `ch_${string}`) => Buffer);
            }], readonly ["toId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["amount", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["stateHash", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `st_${string}`) => Buffer);
            }], readonly ["round", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        521: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelForceProgressTx);
                serialize: ((value?: ChannelForceProgressTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["channelId", {
                deserialize: ((value: Buffer) => `ch_${string}`);
                serialize: ((value: `ch_${string}`) => Buffer);
            }], readonly ["fromId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["payload", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `tx_${string}`) => Buffer);
            }], readonly ["round", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["update", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `cb_${string}`) => Buffer);
            }], readonly ["stateHash", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `st_${string}`) => Buffer);
            }], readonly ["offChainTrees", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `ss_${string}`) => Buffer);
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        53: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelCloseMutualTx);
                serialize: ((value?: ChannelCloseMutualTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["channelId", {
                deserialize: ((value: Buffer) => `ch_${string}`);
                serialize: ((value: `ch_${string}`) => Buffer);
            }], readonly ["fromId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["initiatorAmountFinal", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["responderAmountFinal", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        54: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelCloseSoloTx);
                serialize: ((value?: ChannelCloseSoloTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["channelId", {
                deserialize: ((value: Buffer) => `ch_${string}`);
                serialize: ((value: `ch_${string}`) => Buffer);
            }], readonly ["fromId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["payload", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `tx_${string}`) => Buffer);
            }], readonly ["poi", {
                deserialize: ((value: Buffer, options: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }) => any);
                serialize: ((value: any, options: {
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                }) => Buffer);
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        55: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelSlashTx);
                serialize: ((value?: ChannelSlashTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["channelId", {
                deserialize: ((value: Buffer) => `ch_${string}`);
                serialize: ((value: `ch_${string}`) => Buffer);
            }], readonly ["fromId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["payload", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `tx_${string}`) => Buffer);
            }], readonly ["poi", {
                deserialize: ((value: Buffer, options: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }) => any);
                serialize: ((value: any, options: {
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                }) => Buffer);
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        56: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelSettleTx);
                serialize: ((value?: ChannelSettleTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["channelId", {
                deserialize: ((value: Buffer) => `ch_${string}`);
                serialize: ((value: `ch_${string}`) => Buffer);
            }], readonly ["fromId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["initiatorAmountFinal", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["responderAmountFinal", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        57: {
            2: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelOffChainTx);
                serialize: ((value?: ChannelOffChainTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 2);
                serialize: ((value?: 2) => Buffer);
            }], readonly ["channelId", {
                deserialize: ((value: Buffer) => `ch_${string}`);
                serialize: ((value: `ch_${string}`) => Buffer);
            }], readonly ["round", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["stateHash", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `st_${string}`) => Buffer);
            }]];
        };
        570: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelOffChainUpdateTransfer);
                serialize: ((value?: ChannelOffChainUpdateTransfer) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["from", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["to", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["amount", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }]];
        };
        571: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelOffChainUpdateDeposit);
                serialize: ((value?: ChannelOffChainUpdateDeposit) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["from", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["amount", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }]];
        };
        572: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelOffChainUpdateWithdraw);
                serialize: ((value?: ChannelOffChainUpdateWithdraw) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["from", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["amount", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }]];
        };
        573: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelOffChainUpdateCreateContract);
                serialize: ((value?: ChannelOffChainUpdateCreateContract) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["owner", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["ctVersion", {
                deserialize(buffer: Buffer): CtVersion;
                serialize(value: undefined | CtVersion, __namedParameters: {
                    consensusProtocolVersion: Iris;
                }): Buffer;
            }], readonly ["code", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `cb_${string}`) => Buffer);
            }], readonly ["deposit", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["callData", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `cb_${string}`) => Buffer);
            }]];
        };
        574: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelOffChainUpdateCallContract);
                serialize: ((value?: ChannelOffChainUpdateCallContract) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["caller", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["contract", {
                deserialize: ((value: Buffer) => `ct_${string}`);
                serialize: ((value: `ct_${string}`) => Buffer);
            }], readonly ["abiVersion", {
                deserialize(buffer: Buffer): AbiVersion;
                serialize(value: undefined | AbiVersion, __namedParameters: {
                    consensusProtocolVersion: Iris;
                    tag: Tag;
                }): Buffer;
            }], readonly ["amount", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["callData", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `cb_${string}`) => Buffer);
            }], readonly ["callStack", {
                deserialize(buffer: Buffer): Buffer;
                serialize(buffer: Uint8Array): Buffer;
            }], readonly ["gasPrice", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value?: undefined | string): string;
            }], readonly ["gasLimit", {
                deserialize(value: Buffer): number;
                serialize(_value: undefined | number, __namedParameters: {
                    _computingGasLimit?: number;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    gasMax: number;
                    rebuildTx: ((params: any) => any);
                    tag: Tag;
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): Buffer;
            }]];
        };
        575: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelClientReconnectTx);
                serialize: ((value?: ChannelClientReconnectTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["channelId", {
                deserialize: ((value: Buffer) => `ch_${string}`);
                serialize: ((value: `ch_${string}`) => Buffer);
            }], readonly ["round", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["role", {
                deserialize(buffer: Buffer): string;
                serialize(string: string): Buffer;
            }], readonly ["pubkey", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }]];
        };
        58: {
            3: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => Channel);
                serialize: ((value?: Channel) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 3);
                serialize: ((value?: 3) => Buffer);
            }], readonly ["initiator", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["responder", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["channelAmount", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["initiatorAmount", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["responderAmount", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["channelReserve", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["initiatorDelegateIds", {
                deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
            }], readonly ["responderDelegateIds", {
                deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
            }], readonly ["stateHash", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `st_${string}`) => Buffer);
            }], readonly ["round", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["soloRound", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["lockPeriod", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["lockedUntil", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["initiatorAuth", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `cb_${string}`) => Buffer);
            }], readonly ["responderAuth", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `cb_${string}`) => Buffer);
            }]];
        };
        59: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelSnapshotSoloTx);
                serialize: ((value?: ChannelSnapshotSoloTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["channelId", {
                deserialize: ((value: Buffer) => `ch_${string}`);
                serialize: ((value: `ch_${string}`) => Buffer);
            }], readonly ["fromId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["payload", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `tx_${string}`) => Buffer);
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        60: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => TreesPoi);
                serialize: ((value?: TreesPoi) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["accounts", {
                deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<AccountAddress, Account>[]);
                serialize: ((value: MPTree<AccountAddress, Account>[], params: unknown) => MPTreeBinary[]);
            }], readonly ["calls", {
                deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<Bytearray, ContractCall>[]);
                serialize: ((value: MPTree<Bytearray, ContractCall>[], params: unknown) => MPTreeBinary[]);
            }], readonly ["channels", {
                deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<Channel, Channel>[]);
                serialize: ((value: MPTree<Channel, Channel>[], params: unknown) => MPTreeBinary[]);
            }], readonly ["contracts", {
                deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<ContractAddress, Contract>[]);
                serialize: ((value: MPTree<ContractAddress, Contract>[], params: unknown) => MPTreeBinary[]);
            }], readonly ["ns", {
                deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<Name, Name>[]);
                serialize: ((value: MPTree<Name, Name>[], params: unknown) => MPTreeBinary[]);
            }], readonly ["oracles", {
                deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<OracleAddress, Oracle>[]);
                serialize: ((value: MPTree<OracleAddress, Oracle>[], params: unknown) => MPTreeBinary[]);
            }]];
        };
        62: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => StateTrees);
                serialize: ((value?: StateTrees) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["contracts", {
                deserialize: ((value: Buffer, options: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }) => any);
                serialize: ((value: any, options: {
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                }) => Buffer);
            }], readonly ["calls", {
                deserialize: ((value: Buffer, options: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }) => any);
                serialize: ((value: any, options: {
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                }) => Buffer);
            }], readonly ["channels", {
                deserialize: ((value: Buffer, options: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }) => any);
                serialize: ((value: any, options: {
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                }) => Buffer);
            }], readonly ["ns", {
                deserialize: ((value: Buffer, options: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }) => any);
                serialize: ((value: any, options: {
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                }) => Buffer);
            }], readonly ["oracles", {
                deserialize: ((value: Buffer, options: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }) => any);
                serialize: ((value: any, options: {
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                }) => Buffer);
            }], readonly ["accounts", {
                deserialize: ((value: Buffer, options: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }) => any);
                serialize: ((value: any, options: {
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                }) => Buffer);
            }]];
        };
        621: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ContractsMtree);
                serialize: ((value?: ContractsMtree) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["contracts", {
                deserialize: ((value: Buffer, options: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }) => any);
                serialize: ((value: any, options: {
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                }) => Buffer);
            }]];
        };
        622: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => CallsMtree);
                serialize: ((value?: CallsMtree) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["calls", {
                deserialize: ((value: Buffer, options: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }) => any);
                serialize: ((value: any, options: {
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                }) => Buffer);
            }]];
        };
        623: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelsMtree);
                serialize: ((value?: ChannelsMtree) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["channels", {
                deserialize: ((value: Buffer, options: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }) => any);
                serialize: ((value: any, options: {
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                }) => Buffer);
            }]];
        };
        624: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => NameserviceMtree);
                serialize: ((value?: NameserviceMtree) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["mtree", {
                deserialize: ((value: Buffer, options: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }) => any);
                serialize: ((value: any, options: {
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                }) => Buffer);
            }]];
        };
        625: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => OraclesMtree);
                serialize: ((value?: OraclesMtree) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["otree", {
                deserialize: ((value: Buffer, options: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }) => any);
                serialize: ((value: any, options: {
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                }) => Buffer);
            }]];
        };
        626: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => AccountsMtree);
                serialize: ((value?: AccountsMtree) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["accounts", {
                deserialize: ((value: Buffer, options: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }) => any);
                serialize: ((value: any, options: {
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                }) => Buffer);
            }]];
        };
        63: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => Mtree);
                serialize: ((value?: Mtree) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["values", {
                deserialize: ((value: Buffer[], params: unknown) => any[]);
                serialize: ((value: any[], params: unknown) => Buffer[]);
            }]];
        };
        64: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => MtreeValue);
                serialize: ((value?: MtreeValue) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["key", {
                deserialize(buffer: Buffer): Buffer;
                serialize(buffer: Uint8Array): Buffer;
            }], readonly ["value", {
                deserialize(buffer: Buffer): Buffer;
                serialize(buffer: Uint8Array): Buffer;
            }]];
        };
        80: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => GaAttachTx);
                serialize: ((value?: GaAttachTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["ownerId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["code", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `cb_${string}`) => Buffer);
            }], readonly ["authFun", {
                deserialize(buffer: Buffer): Buffer;
                serialize(buffer: Uint8Array): Buffer;
            }], readonly ["ctVersion", {
                deserialize(buffer: Buffer): CtVersion;
                serialize(value: undefined | CtVersion, __namedParameters: {
                    consensusProtocolVersion: Iris;
                }): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["gasLimit", {
                deserialize(value: Buffer): number;
                serialize(_value: undefined | number, __namedParameters: {
                    _computingGasLimit?: number;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    gasMax: number;
                    rebuildTx: ((params: any) => any);
                    tag: Tag;
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): Buffer;
            }], readonly ["gasPrice", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value?: undefined | string): string;
            }], readonly ["callData", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `cb_${string}`) => Buffer);
            }]];
        };
        81: {
            2: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => GaMetaTx);
                serialize: ((value?: GaMetaTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 2);
                serialize: ((value?: 2) => Buffer);
            }], readonly ["gaId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["authData", {
                deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                serialize: ((value: `cb_${string}`) => Buffer);
            }], readonly ["abiVersion", {
                deserialize(buffer: Buffer): AbiVersion;
                serialize(value: undefined | AbiVersion, __namedParameters: {
                    consensusProtocolVersion: Iris;
                    tag: Tag;
                }): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["gasLimit", {
                deserialize(value: Buffer): number;
                serialize(_value: undefined | number, __namedParameters: {
                    _computingGasLimit?: number;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    gasMax: number;
                    rebuildTx: ((params: any) => any);
                    tag: Tag;
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): Buffer;
            }], readonly ["gasPrice", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value?: undefined | string): string;
            }], readonly ["tx", {
                deserialize: ((value: Buffer, options: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }) => any);
                serialize: ((value: any, options: {
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                }) => Buffer);
            }]];
        };
        82: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => PayingForTx);
                serialize: ((value?: PayingForTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["payerId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["tx", {
                deserialize: ((value: Buffer, options: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                }) => any);
                serialize: ((value: any, options: {
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                }) => Buffer);
            }]];
        };
    }[TxType]>, number>;
} & Omit<TxTypeSchemaBy<TxType, Extract<KeysOfUnion<{
    10: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => Account);
            serialize: ((value?: Account) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["balance", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }]];
        2: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => Account);
            serialize: ((value?: Account) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 2);
            serialize: ((value?: 2) => Buffer);
        }], readonly ["flags", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["balance", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["gaContract", {
            deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
            serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
        }], readonly ["gaAuthFun", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `cb_${string}`) => Buffer);
        }]];
    };
    11: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => SignedTx);
            serialize: ((value?: SignedTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["signatures", {
            deserialize: ((value: Buffer[], params: unknown) => Buffer[]);
            serialize: ((value: Uint8Array[], params: unknown) => Buffer[]);
        }], readonly ["encodedTx", {
            deserialize: ((value: Buffer, options: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }) => any);
            serialize: ((value: any, options: {
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
            }) => Buffer);
        }]];
    };
    12: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => SpendTx);
            serialize: ((value?: SpendTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["senderId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["recipientId", {
            deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
            serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
        }], readonly ["amount", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value: undefined | string): string;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["payload", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value?: `ba_${string}`) => Buffer);
        }]];
    };
    20: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => Oracle);
            serialize: ((value?: Oracle) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["accountId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["queryFormat", {
            deserialize(buffer: Buffer): string;
            serialize(string: string): Buffer;
        }], readonly ["responseFormat", {
            deserialize(buffer: Buffer): string;
            serialize(string: string): Buffer;
        }], readonly ["queryFee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value: undefined | string): string;
        }], readonly ["oracleTtlValue", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["abiVersion", {
            deserialize(buffer: Buffer): AbiVersion;
            serialize(value: undefined | AbiVersion, __namedParameters: {
                consensusProtocolVersion: Iris;
                tag: Tag;
            }): Buffer;
        }]];
    };
    22: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => OracleRegisterTx);
            serialize: ((value?: OracleRegisterTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["accountId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["queryFormat", {
            deserialize(buffer: Buffer): string;
            serialize(string: string): Buffer;
        }], readonly ["responseFormat", {
            deserialize(buffer: Buffer): string;
            serialize(string: string): Buffer;
        }], readonly ["queryFee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value: undefined | string): string;
        }], readonly ["oracleTtlType", {
            deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
            serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
        }], readonly ["oracleTtlValue", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["abiVersion", {
            deserialize(buffer: Buffer): AbiVersion;
            serialize(value: undefined | AbiVersion, __namedParameters: {
                consensusProtocolVersion: Iris;
                tag: Tag;
            }): Buffer;
        }]];
    };
    23: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => OracleQueryTx);
            serialize: ((value?: OracleQueryTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["senderId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["oracleId", {
            deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
            serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
        }], readonly ["query", {
            deserialize(buffer: Buffer): string;
            serialize(string: string): Buffer;
        }], readonly ["queryFee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value: undefined | string): string;
        }], readonly ["queryTtlType", {
            deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
            serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
        }], readonly ["queryTtlValue", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["responseTtlType", {
            deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
            serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
        }], readonly ["responseTtlValue", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    24: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => OracleResponseTx);
            serialize: ((value?: OracleResponseTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["oracleId", {
            deserialize: ((value: Buffer) => `ok_${string}`);
            serialize: ((value: `ok_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["queryId", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `oq_${string}`) => Buffer);
        }], readonly ["response", {
            deserialize(buffer: Buffer): string;
            serialize(string: string): Buffer;
        }], readonly ["responseTtlType", {
            deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
            serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
        }], readonly ["responseTtlValue", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    25: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => OracleExtendTx);
            serialize: ((value?: OracleExtendTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["oracleId", {
            deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
            serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["oracleTtlType", {
            deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
            serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
        }], readonly ["oracleTtlValue", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    30: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => Name);
            serialize: ((value?: Name) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["accountId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nameTtl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["status", {
            deserialize(buffer: Buffer): Buffer;
            serialize(buffer: Uint8Array): Buffer;
        }], readonly ["clientTtl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["pointers", {
            deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
            serialize(pointers: NamePointer[]): Buffer[][];
        }]];
    };
    32: {
        2: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => NameClaimTx);
            serialize: ((value?: NameClaimTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 2);
            serialize: ((value?: 2) => Buffer);
        }], readonly ["accountId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["name", {
            deserialize(value: Buffer): `${string}.chain`;
            serialize(value: `${string}.chain`): Buffer;
        }], readonly ["nameSalt", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["nameFee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, txFields: {
                name: `${string}.chain`;
            } & Options): Buffer;
            serializeAettos(_value: undefined | string, txFields: {
                name: `${string}.chain`;
            }): string;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    33: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => NamePreclaimTx);
            serialize: ((value?: NamePreclaimTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["accountId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["commitmentId", {
            deserialize: ((value: Buffer) => `cm_${string}`);
            serialize: ((value: `cm_${string}`) => Buffer);
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    34: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => NameUpdateTx);
            serialize: ((value?: NameUpdateTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["accountId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["nameId", {
            deserialize: ((value: Buffer) => `nm_${string}`);
            serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
        }], readonly ["nameTtl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["pointers", {
            deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
            serialize(pointers: NamePointer[]): Buffer[][];
        }], readonly ["clientTtl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    35: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => NameRevokeTx);
            serialize: ((value?: NameRevokeTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["accountId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["nameId", {
            deserialize: ((value: Buffer) => `nm_${string}`);
            serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    36: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => NameTransferTx);
            serialize: ((value?: NameTransferTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["accountId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["nameId", {
            deserialize: ((value: Buffer) => `nm_${string}`);
            serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
        }], readonly ["recipientId", {
            deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
            serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    40: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => Contract);
            serialize: ((value?: Contract) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["owner", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["ctVersion", {
            deserialize(buffer: Buffer): CtVersion;
            serialize(value: undefined | CtVersion, __namedParameters: {
                consensusProtocolVersion: Iris;
            }): Buffer;
        }], readonly ["code", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `cb_${string}`) => Buffer);
        }], readonly ["log", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `cb_${string}`) => Buffer);
        }], readonly ["active", {
            deserialize(buffer: Buffer): boolean;
            serialize(value: boolean): Buffer;
        }], readonly ["referers", {
            deserialize: ((value: Buffer[], params: unknown) => `ak_${string}`[]);
            serialize: ((value: `ak_${string}`[], params: unknown) => Buffer[]);
        }], readonly ["deposit", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, options: Options): Buffer;
            serializeAettos(value: undefined | string): string;
        }]];
    };
    41: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ContractCall);
            serialize: ((value?: ContractCall) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["callerId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["callerNonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["height", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["contractId", {
            deserialize: ((value: Buffer) => `ct_${string}`);
            serialize: ((value: `ct_${string}`) => Buffer);
        }], readonly ["gasPrice", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value?: undefined | string): string;
        }], readonly ["gasUsed", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["returnValue", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `cb_${string}`) => Buffer);
        }], readonly ["returnType", {
            deserialize: ((value: Buffer) => CallReturnType);
            serialize: ((value: CallReturnType) => Buffer);
        }], readonly ["log", {
            deserialize(buffer: Buffer): Buffer;
            serialize(buffer: Uint8Array): Buffer;
        }]];
    };
    42: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ContractCreateTx);
            serialize: ((value?: ContractCreateTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["ownerId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["code", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `cb_${string}`) => Buffer);
        }], readonly ["ctVersion", {
            deserialize(buffer: Buffer): CtVersion;
            serialize(value: undefined | CtVersion, __namedParameters: {
                consensusProtocolVersion: Iris;
            }): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["deposit", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, options: Options): Buffer;
            serializeAettos(value: undefined | string): string;
        }], readonly ["amount", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value: undefined | string): string;
        }], readonly ["gasLimit", {
            deserialize(value: Buffer): number;
            serialize(_value: undefined | number, __namedParameters: {
                _computingGasLimit?: number;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                gasMax: number;
                rebuildTx: ((params: any) => any);
                tag: Tag;
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): Buffer;
        }], readonly ["gasPrice", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value?: undefined | string): string;
        }], readonly ["callData", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `cb_${string}`) => Buffer);
        }]];
    };
    43: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ContractCallTx);
            serialize: ((value?: ContractCallTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["callerId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["contractId", {
            deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
            serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
        }], readonly ["abiVersion", {
            deserialize(buffer: Buffer): AbiVersion;
            serialize(value: undefined | AbiVersion, __namedParameters: {
                consensusProtocolVersion: Iris;
                tag: Tag;
            }): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["amount", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value: undefined | string): string;
        }], readonly ["gasLimit", {
            deserialize(value: Buffer): number;
            serialize(_value: undefined | number, __namedParameters: {
                _computingGasLimit?: number;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                gasMax: number;
                rebuildTx: ((params: any) => any);
                tag: Tag;
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): Buffer;
        }], readonly ["gasPrice", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value?: undefined | string): string;
        }], readonly ["callData", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `cb_${string}`) => Buffer);
        }]];
    };
    50: {
        2: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelCreateTx);
            serialize: ((value?: ChannelCreateTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 2);
            serialize: ((value?: 2) => Buffer);
        }], readonly ["initiator", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["initiatorAmount", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["responder", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["responderAmount", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["channelReserve", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["lockPeriod", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["initiatorDelegateIds", {
            deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
            serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
        }], readonly ["responderDelegateIds", {
            deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
            serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
        }], readonly ["stateHash", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `st_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    51: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelDepositTx);
            serialize: ((value?: ChannelDepositTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["channelId", {
            deserialize: ((value: Buffer) => `ch_${string}`);
            serialize: ((value: `ch_${string}`) => Buffer);
        }], readonly ["fromId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["amount", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["stateHash", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `st_${string}`) => Buffer);
        }], readonly ["round", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    52: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelWithdrawTx);
            serialize: ((value?: ChannelWithdrawTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["channelId", {
            deserialize: ((value: Buffer) => `ch_${string}`);
            serialize: ((value: `ch_${string}`) => Buffer);
        }], readonly ["toId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["amount", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["stateHash", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `st_${string}`) => Buffer);
        }], readonly ["round", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    521: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelForceProgressTx);
            serialize: ((value?: ChannelForceProgressTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["channelId", {
            deserialize: ((value: Buffer) => `ch_${string}`);
            serialize: ((value: `ch_${string}`) => Buffer);
        }], readonly ["fromId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["payload", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `tx_${string}`) => Buffer);
        }], readonly ["round", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["update", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `cb_${string}`) => Buffer);
        }], readonly ["stateHash", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `st_${string}`) => Buffer);
        }], readonly ["offChainTrees", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `ss_${string}`) => Buffer);
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    53: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelCloseMutualTx);
            serialize: ((value?: ChannelCloseMutualTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["channelId", {
            deserialize: ((value: Buffer) => `ch_${string}`);
            serialize: ((value: `ch_${string}`) => Buffer);
        }], readonly ["fromId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["initiatorAmountFinal", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["responderAmountFinal", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    54: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelCloseSoloTx);
            serialize: ((value?: ChannelCloseSoloTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["channelId", {
            deserialize: ((value: Buffer) => `ch_${string}`);
            serialize: ((value: `ch_${string}`) => Buffer);
        }], readonly ["fromId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["payload", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `tx_${string}`) => Buffer);
        }], readonly ["poi", {
            deserialize: ((value: Buffer, options: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }) => any);
            serialize: ((value: any, options: {
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
            }) => Buffer);
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    55: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelSlashTx);
            serialize: ((value?: ChannelSlashTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["channelId", {
            deserialize: ((value: Buffer) => `ch_${string}`);
            serialize: ((value: `ch_${string}`) => Buffer);
        }], readonly ["fromId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["payload", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `tx_${string}`) => Buffer);
        }], readonly ["poi", {
            deserialize: ((value: Buffer, options: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }) => any);
            serialize: ((value: any, options: {
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
            }) => Buffer);
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    56: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelSettleTx);
            serialize: ((value?: ChannelSettleTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["channelId", {
            deserialize: ((value: Buffer) => `ch_${string}`);
            serialize: ((value: `ch_${string}`) => Buffer);
        }], readonly ["fromId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["initiatorAmountFinal", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["responderAmountFinal", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    57: {
        2: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelOffChainTx);
            serialize: ((value?: ChannelOffChainTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 2);
            serialize: ((value?: 2) => Buffer);
        }], readonly ["channelId", {
            deserialize: ((value: Buffer) => `ch_${string}`);
            serialize: ((value: `ch_${string}`) => Buffer);
        }], readonly ["round", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["stateHash", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `st_${string}`) => Buffer);
        }]];
    };
    570: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelOffChainUpdateTransfer);
            serialize: ((value?: ChannelOffChainUpdateTransfer) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["from", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["to", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["amount", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }]];
    };
    571: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelOffChainUpdateDeposit);
            serialize: ((value?: ChannelOffChainUpdateDeposit) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["from", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["amount", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }]];
    };
    572: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelOffChainUpdateWithdraw);
            serialize: ((value?: ChannelOffChainUpdateWithdraw) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["from", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["amount", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }]];
    };
    573: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelOffChainUpdateCreateContract);
            serialize: ((value?: ChannelOffChainUpdateCreateContract) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["owner", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["ctVersion", {
            deserialize(buffer: Buffer): CtVersion;
            serialize(value: undefined | CtVersion, __namedParameters: {
                consensusProtocolVersion: Iris;
            }): Buffer;
        }], readonly ["code", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `cb_${string}`) => Buffer);
        }], readonly ["deposit", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["callData", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `cb_${string}`) => Buffer);
        }]];
    };
    574: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelOffChainUpdateCallContract);
            serialize: ((value?: ChannelOffChainUpdateCallContract) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["caller", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["contract", {
            deserialize: ((value: Buffer) => `ct_${string}`);
            serialize: ((value: `ct_${string}`) => Buffer);
        }], readonly ["abiVersion", {
            deserialize(buffer: Buffer): AbiVersion;
            serialize(value: undefined | AbiVersion, __namedParameters: {
                consensusProtocolVersion: Iris;
                tag: Tag;
            }): Buffer;
        }], readonly ["amount", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["callData", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `cb_${string}`) => Buffer);
        }], readonly ["callStack", {
            deserialize(buffer: Buffer): Buffer;
            serialize(buffer: Uint8Array): Buffer;
        }], readonly ["gasPrice", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value?: undefined | string): string;
        }], readonly ["gasLimit", {
            deserialize(value: Buffer): number;
            serialize(_value: undefined | number, __namedParameters: {
                _computingGasLimit?: number;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                gasMax: number;
                rebuildTx: ((params: any) => any);
                tag: Tag;
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): Buffer;
        }]];
    };
    575: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelClientReconnectTx);
            serialize: ((value?: ChannelClientReconnectTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["channelId", {
            deserialize: ((value: Buffer) => `ch_${string}`);
            serialize: ((value: `ch_${string}`) => Buffer);
        }], readonly ["round", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["role", {
            deserialize(buffer: Buffer): string;
            serialize(string: string): Buffer;
        }], readonly ["pubkey", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }]];
    };
    58: {
        3: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => Channel);
            serialize: ((value?: Channel) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 3);
            serialize: ((value?: 3) => Buffer);
        }], readonly ["initiator", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["responder", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["channelAmount", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["initiatorAmount", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["responderAmount", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["channelReserve", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["initiatorDelegateIds", {
            deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
            serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
        }], readonly ["responderDelegateIds", {
            deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
            serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
        }], readonly ["stateHash", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `st_${string}`) => Buffer);
        }], readonly ["round", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["soloRound", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["lockPeriod", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["lockedUntil", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["initiatorAuth", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `cb_${string}`) => Buffer);
        }], readonly ["responderAuth", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `cb_${string}`) => Buffer);
        }]];
    };
    59: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelSnapshotSoloTx);
            serialize: ((value?: ChannelSnapshotSoloTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["channelId", {
            deserialize: ((value: Buffer) => `ch_${string}`);
            serialize: ((value: `ch_${string}`) => Buffer);
        }], readonly ["fromId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["payload", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `tx_${string}`) => Buffer);
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    60: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => TreesPoi);
            serialize: ((value?: TreesPoi) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["accounts", {
            deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<AccountAddress, Account>[]);
            serialize: ((value: MPTree<AccountAddress, Account>[], params: unknown) => MPTreeBinary[]);
        }], readonly ["calls", {
            deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<Bytearray, ContractCall>[]);
            serialize: ((value: MPTree<Bytearray, ContractCall>[], params: unknown) => MPTreeBinary[]);
        }], readonly ["channels", {
            deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<Channel, Channel>[]);
            serialize: ((value: MPTree<Channel, Channel>[], params: unknown) => MPTreeBinary[]);
        }], readonly ["contracts", {
            deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<ContractAddress, Contract>[]);
            serialize: ((value: MPTree<ContractAddress, Contract>[], params: unknown) => MPTreeBinary[]);
        }], readonly ["ns", {
            deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<Name, Name>[]);
            serialize: ((value: MPTree<Name, Name>[], params: unknown) => MPTreeBinary[]);
        }], readonly ["oracles", {
            deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<OracleAddress, Oracle>[]);
            serialize: ((value: MPTree<OracleAddress, Oracle>[], params: unknown) => MPTreeBinary[]);
        }]];
    };
    62: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => StateTrees);
            serialize: ((value?: StateTrees) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["contracts", {
            deserialize: ((value: Buffer, options: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }) => any);
            serialize: ((value: any, options: {
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
            }) => Buffer);
        }], readonly ["calls", {
            deserialize: ((value: Buffer, options: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }) => any);
            serialize: ((value: any, options: {
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
            }) => Buffer);
        }], readonly ["channels", {
            deserialize: ((value: Buffer, options: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }) => any);
            serialize: ((value: any, options: {
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
            }) => Buffer);
        }], readonly ["ns", {
            deserialize: ((value: Buffer, options: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }) => any);
            serialize: ((value: any, options: {
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
            }) => Buffer);
        }], readonly ["oracles", {
            deserialize: ((value: Buffer, options: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }) => any);
            serialize: ((value: any, options: {
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
            }) => Buffer);
        }], readonly ["accounts", {
            deserialize: ((value: Buffer, options: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }) => any);
            serialize: ((value: any, options: {
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
            }) => Buffer);
        }]];
    };
    621: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ContractsMtree);
            serialize: ((value?: ContractsMtree) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["contracts", {
            deserialize: ((value: Buffer, options: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }) => any);
            serialize: ((value: any, options: {
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
            }) => Buffer);
        }]];
    };
    622: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => CallsMtree);
            serialize: ((value?: CallsMtree) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["calls", {
            deserialize: ((value: Buffer, options: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }) => any);
            serialize: ((value: any, options: {
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
            }) => Buffer);
        }]];
    };
    623: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelsMtree);
            serialize: ((value?: ChannelsMtree) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["channels", {
            deserialize: ((value: Buffer, options: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }) => any);
            serialize: ((value: any, options: {
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
            }) => Buffer);
        }]];
    };
    624: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => NameserviceMtree);
            serialize: ((value?: NameserviceMtree) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["mtree", {
            deserialize: ((value: Buffer, options: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }) => any);
            serialize: ((value: any, options: {
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
            }) => Buffer);
        }]];
    };
    625: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => OraclesMtree);
            serialize: ((value?: OraclesMtree) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["otree", {
            deserialize: ((value: Buffer, options: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }) => any);
            serialize: ((value: any, options: {
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
            }) => Buffer);
        }]];
    };
    626: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => AccountsMtree);
            serialize: ((value?: AccountsMtree) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["accounts", {
            deserialize: ((value: Buffer, options: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }) => any);
            serialize: ((value: any, options: {
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
            }) => Buffer);
        }]];
    };
    63: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => Mtree);
            serialize: ((value?: Mtree) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["values", {
            deserialize: ((value: Buffer[], params: unknown) => any[]);
            serialize: ((value: any[], params: unknown) => Buffer[]);
        }]];
    };
    64: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => MtreeValue);
            serialize: ((value?: MtreeValue) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["key", {
            deserialize(buffer: Buffer): Buffer;
            serialize(buffer: Uint8Array): Buffer;
        }], readonly ["value", {
            deserialize(buffer: Buffer): Buffer;
            serialize(buffer: Uint8Array): Buffer;
        }]];
    };
    80: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => GaAttachTx);
            serialize: ((value?: GaAttachTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["ownerId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["code", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `cb_${string}`) => Buffer);
        }], readonly ["authFun", {
            deserialize(buffer: Buffer): Buffer;
            serialize(buffer: Uint8Array): Buffer;
        }], readonly ["ctVersion", {
            deserialize(buffer: Buffer): CtVersion;
            serialize(value: undefined | CtVersion, __namedParameters: {
                consensusProtocolVersion: Iris;
            }): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["gasLimit", {
            deserialize(value: Buffer): number;
            serialize(_value: undefined | number, __namedParameters: {
                _computingGasLimit?: number;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                gasMax: number;
                rebuildTx: ((params: any) => any);
                tag: Tag;
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): Buffer;
        }], readonly ["gasPrice", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value?: undefined | string): string;
        }], readonly ["callData", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `cb_${string}`) => Buffer);
        }]];
    };
    81: {
        2: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => GaMetaTx);
            serialize: ((value?: GaMetaTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 2);
            serialize: ((value?: 2) => Buffer);
        }], readonly ["gaId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["authData", {
            deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
            serialize: ((value: `cb_${string}`) => Buffer);
        }], readonly ["abiVersion", {
            deserialize(buffer: Buffer): AbiVersion;
            serialize(value: undefined | AbiVersion, __namedParameters: {
                consensusProtocolVersion: Iris;
                tag: Tag;
            }): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["gasLimit", {
            deserialize(value: Buffer): number;
            serialize(_value: undefined | number, __namedParameters: {
                _computingGasLimit?: number;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                gasMax: number;
                rebuildTx: ((params: any) => any);
                tag: Tag;
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): Buffer;
        }], readonly ["gasPrice", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value?: undefined | string): string;
        }], readonly ["tx", {
            deserialize: ((value: Buffer, options: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }) => any);
            serialize: ((value: any, options: {
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
            }) => Buffer);
        }]];
    };
    82: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => PayingForTx);
            serialize: ((value?: PayingForTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["payerId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["tx", {
            deserialize: ((value: Buffer, options: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
            }) => any);
            serialize: ((value: any, options: {
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
            }) => Buffer);
        }]];
    };
}[TxType]>, number>>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
    gasMax?: number;
} : {}), "nonce" | "ttl" | "tag"> & {
    absoluteTtl?: boolean;
    denomination?: AE_AMOUNT_FORMATS;
    nonce?: number;
    onNode: Node;
    strategy?: "max" | "continuity";
    ttl?: number;
} & (TxType extends OracleResponseTx | OracleExtendTx ? {
    callerId: `ak_${string}`;
} : {}), "onNode"> & {
    onNode?: Node;
}): Promise<`tx_${string}`>
Type Parameters
- TxType extends Tag
Parameters
- txType: TxType
- options: Omit<Omit<{
      tag: TxType;
      version?: Extract<KeysOfUnion<{
          10: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Account);
                  serialize: ((value?: Account) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["balance", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }]];
              2: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Account);
                  serialize: ((value?: Account) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 2);
                  serialize: ((value?: 2) => Buffer);
              }], readonly ["flags", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["balance", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["gaContract", {
                  deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
                  serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["gaAuthFun", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }]];
          };
          11: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => SignedTx);
                  serialize: ((value?: SignedTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["signatures", {
                  deserialize: ((value: Buffer[], params: unknown) => Buffer[]);
                  serialize: ((value: Uint8Array[], params: unknown) => Buffer[]);
              }], readonly ["encodedTx", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }]];
          };
          12: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => SpendTx);
                  serialize: ((value?: SpendTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["senderId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["recipientId", {
                  deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
                  serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["payload", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value?: `ba_${string}`) => Buffer);
              }]];
          };
          20: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Oracle);
                  serialize: ((value?: Oracle) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["queryFormat", {
                  deserialize(buffer: Buffer): string;
                  serialize(string: string): Buffer;
              }], readonly ["responseFormat", {
                  deserialize(buffer: Buffer): string;
                  serialize(string: string): Buffer;
              }], readonly ["queryFee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["oracleTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["abiVersion", {
                  deserialize(buffer: Buffer): AbiVersion;
                  serialize(value: undefined | AbiVersion, __namedParameters: {
                      consensusProtocolVersion: Iris;
                      tag: Tag;
                  }): Buffer;
              }]];
          };
          22: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => OracleRegisterTx);
                  serialize: ((value?: OracleRegisterTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["queryFormat", {
                  deserialize(buffer: Buffer): string;
                  serialize(string: string): Buffer;
              }], readonly ["responseFormat", {
                  deserialize(buffer: Buffer): string;
                  serialize(string: string): Buffer;
              }], readonly ["queryFee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["oracleTtlType", {
                  deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                  serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
              }], readonly ["oracleTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["abiVersion", {
                  deserialize(buffer: Buffer): AbiVersion;
                  serialize(value: undefined | AbiVersion, __namedParameters: {
                      consensusProtocolVersion: Iris;
                      tag: Tag;
                  }): Buffer;
              }]];
          };
          23: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => OracleQueryTx);
                  serialize: ((value?: OracleQueryTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["senderId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["oracleId", {
                  deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
                  serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["query", {
                  deserialize(buffer: Buffer): string;
                  serialize(string: string): Buffer;
              }], readonly ["queryFee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["queryTtlType", {
                  deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                  serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
              }], readonly ["queryTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["responseTtlType", {
                  deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                  serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
              }], readonly ["responseTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          24: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => OracleResponseTx);
                  serialize: ((value?: OracleResponseTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["oracleId", {
                  deserialize: ((value: Buffer) => `ok_${string}`);
                  serialize: ((value: `ok_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["queryId", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `oq_${string}`) => Buffer);
              }], readonly ["response", {
                  deserialize(buffer: Buffer): string;
                  serialize(string: string): Buffer;
              }], readonly ["responseTtlType", {
                  deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                  serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
              }], readonly ["responseTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          25: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => OracleExtendTx);
                  serialize: ((value?: OracleExtendTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["oracleId", {
                  deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
                  serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["oracleTtlType", {
                  deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                  serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
              }], readonly ["oracleTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          30: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Name);
                  serialize: ((value?: Name) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nameTtl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["status", {
                  deserialize(buffer: Buffer): Buffer;
                  serialize(buffer: Uint8Array): Buffer;
              }], readonly ["clientTtl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["pointers", {
                  deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
                  serialize(pointers: NamePointer[]): Buffer[][];
              }]];
          };
          32: {
              2: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NameClaimTx);
                  serialize: ((value?: NameClaimTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 2);
                  serialize: ((value?: 2) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["name", {
                  deserialize(value: Buffer): `${string}.chain`;
                  serialize(value: `${string}.chain`): Buffer;
              }], readonly ["nameSalt", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["nameFee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, txFields: {
                      name: `${string}.chain`;
                  } & Options): Buffer;
                  serializeAettos(_value: undefined | string, txFields: {
                      name: `${string}.chain`;
                  }): string;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          33: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NamePreclaimTx);
                  serialize: ((value?: NamePreclaimTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["commitmentId", {
                  deserialize: ((value: Buffer) => `cm_${string}`);
                  serialize: ((value: `cm_${string}`) => Buffer);
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          34: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NameUpdateTx);
                  serialize: ((value?: NameUpdateTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nameId", {
                  deserialize: ((value: Buffer) => `nm_${string}`);
                  serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
              }], readonly ["nameTtl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["pointers", {
                  deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
                  serialize(pointers: NamePointer[]): Buffer[][];
              }], readonly ["clientTtl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          35: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NameRevokeTx);
                  serialize: ((value?: NameRevokeTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nameId", {
                  deserialize: ((value: Buffer) => `nm_${string}`);
                  serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          36: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NameTransferTx);
                  serialize: ((value?: NameTransferTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nameId", {
                  deserialize: ((value: Buffer) => `nm_${string}`);
                  serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
              }], readonly ["recipientId", {
                  deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
                  serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          40: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Contract);
                  serialize: ((value?: Contract) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["owner", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["ctVersion", {
                  deserialize(buffer: Buffer): CtVersion;
                  serialize(value: undefined | CtVersion, __namedParameters: {
                      consensusProtocolVersion: Iris;
                  }): Buffer;
              }], readonly ["code", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }], readonly ["log", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }], readonly ["active", {
                  deserialize(buffer: Buffer): boolean;
                  serialize(value: boolean): Buffer;
              }], readonly ["referers", {
                  deserialize: ((value: Buffer[], params: unknown) => `ak_${string}`[]);
                  serialize: ((value: `ak_${string}`[], params: unknown) => Buffer[]);
              }], readonly ["deposit", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, options: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }]];
          };
          41: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ContractCall);
                  serialize: ((value?: ContractCall) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["callerId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["callerNonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["height", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["contractId", {
                  deserialize: ((value: Buffer) => `ct_${string}`);
                  serialize: ((value: `ct_${string}`) => Buffer);
              }], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["gasUsed", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["returnValue", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }], readonly ["returnType", {
                  deserialize: ((value: Buffer) => CallReturnType);
                  serialize: ((value: CallReturnType) => Buffer);
              }], readonly ["log", {
                  deserialize(buffer: Buffer): Buffer;
                  serialize(buffer: Uint8Array): Buffer;
              }]];
          };
          42: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ContractCreateTx);
                  serialize: ((value?: ContractCreateTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["ownerId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["code", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }], readonly ["ctVersion", {
                  deserialize(buffer: Buffer): CtVersion;
                  serialize(value: undefined | CtVersion, __namedParameters: {
                      consensusProtocolVersion: Iris;
                  }): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["deposit", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, options: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["gasLimit", {
                  deserialize(value: Buffer): number;
                  serialize(_value: undefined | number, __namedParameters: {
                      _computingGasLimit?: number;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      gasMax: number;
                      rebuildTx: ((params: any) => any);
                      tag: Tag;
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): Buffer;
              }], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["callData", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }]];
          };
          43: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ContractCallTx);
                  serialize: ((value?: ContractCallTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["callerId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["contractId", {
                  deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
                  serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["abiVersion", {
                  deserialize(buffer: Buffer): AbiVersion;
                  serialize(value: undefined | AbiVersion, __namedParameters: {
                      consensusProtocolVersion: Iris;
                      tag: Tag;
                  }): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["gasLimit", {
                  deserialize(value: Buffer): number;
                  serialize(_value: undefined | number, __namedParameters: {
                      _computingGasLimit?: number;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      gasMax: number;
                      rebuildTx: ((params: any) => any);
                      tag: Tag;
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): Buffer;
              }], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["callData", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }]];
          };
          50: {
              2: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelCreateTx);
                  serialize: ((value?: ChannelCreateTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 2);
                  serialize: ((value?: 2) => Buffer);
              }], readonly ["initiator", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["initiatorAmount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["responder", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["responderAmount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["channelReserve", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["lockPeriod", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["initiatorDelegateIds", {
                  deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                  serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
              }], readonly ["responderDelegateIds", {
                  deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                  serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
              }], readonly ["stateHash", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `st_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          51: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelDepositTx);
                  serialize: ((value?: ChannelDepositTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["stateHash", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `st_${string}`) => Buffer);
              }], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          52: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelWithdrawTx);
                  serialize: ((value?: ChannelWithdrawTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["toId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["stateHash", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `st_${string}`) => Buffer);
              }], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          521: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelForceProgressTx);
                  serialize: ((value?: ChannelForceProgressTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["payload", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `tx_${string}`) => Buffer);
              }], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["update", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }], readonly ["stateHash", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `st_${string}`) => Buffer);
              }], readonly ["offChainTrees", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `ss_${string}`) => Buffer);
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          53: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelCloseMutualTx);
                  serialize: ((value?: ChannelCloseMutualTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["initiatorAmountFinal", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["responderAmountFinal", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          54: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelCloseSoloTx);
                  serialize: ((value?: ChannelCloseSoloTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["payload", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `tx_${string}`) => Buffer);
              }], readonly ["poi", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          55: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelSlashTx);
                  serialize: ((value?: ChannelSlashTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["payload", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `tx_${string}`) => Buffer);
              }], readonly ["poi", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          56: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelSettleTx);
                  serialize: ((value?: ChannelSettleTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["initiatorAmountFinal", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["responderAmountFinal", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          57: {
              2: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainTx);
                  serialize: ((value?: ChannelOffChainTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 2);
                  serialize: ((value?: 2) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["stateHash", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `st_${string}`) => Buffer);
              }]];
          };
          570: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainUpdateTransfer);
                  serialize: ((value?: ChannelOffChainUpdateTransfer) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["from", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["to", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }]];
          };
          571: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainUpdateDeposit);
                  serialize: ((value?: ChannelOffChainUpdateDeposit) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["from", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }]];
          };
          572: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainUpdateWithdraw);
                  serialize: ((value?: ChannelOffChainUpdateWithdraw) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["from", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }]];
          };
          573: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainUpdateCreateContract);
                  serialize: ((value?: ChannelOffChainUpdateCreateContract) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["owner", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["ctVersion", {
                  deserialize(buffer: Buffer): CtVersion;
                  serialize(value: undefined | CtVersion, __namedParameters: {
                      consensusProtocolVersion: Iris;
                  }): Buffer;
              }], readonly ["code", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }], readonly ["deposit", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["callData", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }]];
          };
          574: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainUpdateCallContract);
                  serialize: ((value?: ChannelOffChainUpdateCallContract) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["caller", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["contract", {
                  deserialize: ((value: Buffer) => `ct_${string}`);
                  serialize: ((value: `ct_${string}`) => Buffer);
              }], readonly ["abiVersion", {
                  deserialize(buffer: Buffer): AbiVersion;
                  serialize(value: undefined | AbiVersion, __namedParameters: {
                      consensusProtocolVersion: Iris;
                      tag: Tag;
                  }): Buffer;
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["callData", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }], readonly ["callStack", {
                  deserialize(buffer: Buffer): Buffer;
                  serialize(buffer: Uint8Array): Buffer;
              }], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["gasLimit", {
                  deserialize(value: Buffer): number;
                  serialize(_value: undefined | number, __namedParameters: {
                      _computingGasLimit?: number;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      gasMax: number;
                      rebuildTx: ((params: any) => any);
                      tag: Tag;
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): Buffer;
              }]];
          };
          575: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelClientReconnectTx);
                  serialize: ((value?: ChannelClientReconnectTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["role", {
                  deserialize(buffer: Buffer): string;
                  serialize(string: string): Buffer;
              }], readonly ["pubkey", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }]];
          };
          58: {
              3: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Channel);
                  serialize: ((value?: Channel) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 3);
                  serialize: ((value?: 3) => Buffer);
              }], readonly ["initiator", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["responder", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["channelAmount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["initiatorAmount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["responderAmount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["channelReserve", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["initiatorDelegateIds", {
                  deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                  serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
              }], readonly ["responderDelegateIds", {
                  deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                  serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
              }], readonly ["stateHash", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `st_${string}`) => Buffer);
              }], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["soloRound", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["lockPeriod", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["lockedUntil", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["initiatorAuth", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }], readonly ["responderAuth", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }]];
          };
          59: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelSnapshotSoloTx);
                  serialize: ((value?: ChannelSnapshotSoloTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["payload", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `tx_${string}`) => Buffer);
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          60: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => TreesPoi);
                  serialize: ((value?: TreesPoi) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accounts", {
                  deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<AccountAddress, Account>[]);
                  serialize: ((value: MPTree<AccountAddress, Account>[], params: unknown) => MPTreeBinary[]);
              }], readonly ["calls", {
                  deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<Bytearray, ContractCall>[]);
                  serialize: ((value: MPTree<Bytearray, ContractCall>[], params: unknown) => MPTreeBinary[]);
              }], readonly ["channels", {
                  deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<Channel, Channel>[]);
                  serialize: ((value: MPTree<Channel, Channel>[], params: unknown) => MPTreeBinary[]);
              }], readonly ["contracts", {
                  deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<ContractAddress, Contract>[]);
                  serialize: ((value: MPTree<ContractAddress, Contract>[], params: unknown) => MPTreeBinary[]);
              }], readonly ["ns", {
                  deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<Name, Name>[]);
                  serialize: ((value: MPTree<Name, Name>[], params: unknown) => MPTreeBinary[]);
              }], readonly ["oracles", {
                  deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<OracleAddress, Oracle>[]);
                  serialize: ((value: MPTree<OracleAddress, Oracle>[], params: unknown) => MPTreeBinary[]);
              }]];
          };
          62: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => StateTrees);
                  serialize: ((value?: StateTrees) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["contracts", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }], readonly ["calls", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }], readonly ["channels", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }], readonly ["ns", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }], readonly ["oracles", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }], readonly ["accounts", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }]];
          };
          621: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ContractsMtree);
                  serialize: ((value?: ContractsMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["contracts", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }]];
          };
          622: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => CallsMtree);
                  serialize: ((value?: CallsMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["calls", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }]];
          };
          623: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelsMtree);
                  serialize: ((value?: ChannelsMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channels", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }]];
          };
          624: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NameserviceMtree);
                  serialize: ((value?: NameserviceMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["mtree", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }]];
          };
          625: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => OraclesMtree);
                  serialize: ((value?: OraclesMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["otree", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }]];
          };
          626: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => AccountsMtree);
                  serialize: ((value?: AccountsMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accounts", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }]];
          };
          63: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Mtree);
                  serialize: ((value?: Mtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["values", {
                  deserialize: ((value: Buffer[], params: unknown) => any[]);
                  serialize: ((value: any[], params: unknown) => Buffer[]);
              }]];
          };
          64: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => MtreeValue);
                  serialize: ((value?: MtreeValue) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["key", {
                  deserialize(buffer: Buffer): Buffer;
                  serialize(buffer: Uint8Array): Buffer;
              }], readonly ["value", {
                  deserialize(buffer: Buffer): Buffer;
                  serialize(buffer: Uint8Array): Buffer;
              }]];
          };
          80: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => GaAttachTx);
                  serialize: ((value?: GaAttachTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["ownerId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["code", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }], readonly ["authFun", {
                  deserialize(buffer: Buffer): Buffer;
                  serialize(buffer: Uint8Array): Buffer;
              }], readonly ["ctVersion", {
                  deserialize(buffer: Buffer): CtVersion;
                  serialize(value: undefined | CtVersion, __namedParameters: {
                      consensusProtocolVersion: Iris;
                  }): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["gasLimit", {
                  deserialize(value: Buffer): number;
                  serialize(_value: undefined | number, __namedParameters: {
                      _computingGasLimit?: number;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      gasMax: number;
                      rebuildTx: ((params: any) => any);
                      tag: Tag;
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): Buffer;
              }], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["callData", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }]];
          };
          81: {
              2: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => GaMetaTx);
                  serialize: ((value?: GaMetaTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 2);
                  serialize: ((value?: 2) => Buffer);
              }], readonly ["gaId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["authData", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }], readonly ["abiVersion", {
                  deserialize(buffer: Buffer): AbiVersion;
                  serialize(value: undefined | AbiVersion, __namedParameters: {
                      consensusProtocolVersion: Iris;
                      tag: Tag;
                  }): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["gasLimit", {
                  deserialize(value: Buffer): number;
                  serialize(_value: undefined | number, __namedParameters: {
                      _computingGasLimit?: number;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      gasMax: number;
                      rebuildTx: ((params: any) => any);
                      tag: Tag;
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): Buffer;
              }], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["tx", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }]];
          };
          82: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => PayingForTx);
                  serialize: ((value?: PayingForTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["payerId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["tx", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }]];
          };
      }[TxType]>, number>;
  } & Omit<TxTypeSchemaBy<TxType, Extract<KeysOfUnion<{
      10: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => Account);
              serialize: ((value?: Account) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["balance", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }]];
          2: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => Account);
              serialize: ((value?: Account) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 2);
              serialize: ((value?: 2) => Buffer);
          }], readonly ["flags", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["balance", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["gaContract", {
              deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
              serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
          }], readonly ["gaAuthFun", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `cb_${string}`) => Buffer);
          }]];
      };
      11: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => SignedTx);
              serialize: ((value?: SignedTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["signatures", {
              deserialize: ((value: Buffer[], params: unknown) => Buffer[]);
              serialize: ((value: Uint8Array[], params: unknown) => Buffer[]);
          }], readonly ["encodedTx", {
              deserialize: ((value: Buffer, options: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }) => any);
              serialize: ((value: any, options: {
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
              }) => Buffer);
          }]];
      };
      12: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => SpendTx);
              serialize: ((value?: SpendTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["senderId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["recipientId", {
              deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
              serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
          }], readonly ["amount", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value: undefined | string): string;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["payload", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value?: `ba_${string}`) => Buffer);
          }]];
      };
      20: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => Oracle);
              serialize: ((value?: Oracle) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["accountId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["queryFormat", {
              deserialize(buffer: Buffer): string;
              serialize(string: string): Buffer;
          }], readonly ["responseFormat", {
              deserialize(buffer: Buffer): string;
              serialize(string: string): Buffer;
          }], readonly ["queryFee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value: undefined | string): string;
          }], readonly ["oracleTtlValue", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["abiVersion", {
              deserialize(buffer: Buffer): AbiVersion;
              serialize(value: undefined | AbiVersion, __namedParameters: {
                  consensusProtocolVersion: Iris;
                  tag: Tag;
              }): Buffer;
          }]];
      };
      22: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => OracleRegisterTx);
              serialize: ((value?: OracleRegisterTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["accountId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["queryFormat", {
              deserialize(buffer: Buffer): string;
              serialize(string: string): Buffer;
          }], readonly ["responseFormat", {
              deserialize(buffer: Buffer): string;
              serialize(string: string): Buffer;
          }], readonly ["queryFee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value: undefined | string): string;
          }], readonly ["oracleTtlType", {
              deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
              serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
          }], readonly ["oracleTtlValue", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["abiVersion", {
              deserialize(buffer: Buffer): AbiVersion;
              serialize(value: undefined | AbiVersion, __namedParameters: {
                  consensusProtocolVersion: Iris;
                  tag: Tag;
              }): Buffer;
          }]];
      };
      23: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => OracleQueryTx);
              serialize: ((value?: OracleQueryTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["senderId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["oracleId", {
              deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
              serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
          }], readonly ["query", {
              deserialize(buffer: Buffer): string;
              serialize(string: string): Buffer;
          }], readonly ["queryFee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value: undefined | string): string;
          }], readonly ["queryTtlType", {
              deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
              serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
          }], readonly ["queryTtlValue", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["responseTtlType", {
              deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
              serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
          }], readonly ["responseTtlValue", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      24: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => OracleResponseTx);
              serialize: ((value?: OracleResponseTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["oracleId", {
              deserialize: ((value: Buffer) => `ok_${string}`);
              serialize: ((value: `ok_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["queryId", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `oq_${string}`) => Buffer);
          }], readonly ["response", {
              deserialize(buffer: Buffer): string;
              serialize(string: string): Buffer;
          }], readonly ["responseTtlType", {
              deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
              serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
          }], readonly ["responseTtlValue", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      25: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => OracleExtendTx);
              serialize: ((value?: OracleExtendTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["oracleId", {
              deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
              serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["oracleTtlType", {
              deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
              serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
          }], readonly ["oracleTtlValue", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      30: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => Name);
              serialize: ((value?: Name) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["accountId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nameTtl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["status", {
              deserialize(buffer: Buffer): Buffer;
              serialize(buffer: Uint8Array): Buffer;
          }], readonly ["clientTtl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["pointers", {
              deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
              serialize(pointers: NamePointer[]): Buffer[][];
          }]];
      };
      32: {
          2: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => NameClaimTx);
              serialize: ((value?: NameClaimTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 2);
              serialize: ((value?: 2) => Buffer);
          }], readonly ["accountId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["name", {
              deserialize(value: Buffer): `${string}.chain`;
              serialize(value: `${string}.chain`): Buffer;
          }], readonly ["nameSalt", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["nameFee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, txFields: {
                  name: `${string}.chain`;
              } & Options): Buffer;
              serializeAettos(_value: undefined | string, txFields: {
                  name: `${string}.chain`;
              }): string;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      33: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => NamePreclaimTx);
              serialize: ((value?: NamePreclaimTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["accountId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["commitmentId", {
              deserialize: ((value: Buffer) => `cm_${string}`);
              serialize: ((value: `cm_${string}`) => Buffer);
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      34: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => NameUpdateTx);
              serialize: ((value?: NameUpdateTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["accountId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["nameId", {
              deserialize: ((value: Buffer) => `nm_${string}`);
              serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
          }], readonly ["nameTtl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["pointers", {
              deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
              serialize(pointers: NamePointer[]): Buffer[][];
          }], readonly ["clientTtl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      35: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => NameRevokeTx);
              serialize: ((value?: NameRevokeTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["accountId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["nameId", {
              deserialize: ((value: Buffer) => `nm_${string}`);
              serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      36: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => NameTransferTx);
              serialize: ((value?: NameTransferTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["accountId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["nameId", {
              deserialize: ((value: Buffer) => `nm_${string}`);
              serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
          }], readonly ["recipientId", {
              deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
              serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      40: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => Contract);
              serialize: ((value?: Contract) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["owner", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["ctVersion", {
              deserialize(buffer: Buffer): CtVersion;
              serialize(value: undefined | CtVersion, __namedParameters: {
                  consensusProtocolVersion: Iris;
              }): Buffer;
          }], readonly ["code", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `cb_${string}`) => Buffer);
          }], readonly ["log", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `cb_${string}`) => Buffer);
          }], readonly ["active", {
              deserialize(buffer: Buffer): boolean;
              serialize(value: boolean): Buffer;
          }], readonly ["referers", {
              deserialize: ((value: Buffer[], params: unknown) => `ak_${string}`[]);
              serialize: ((value: `ak_${string}`[], params: unknown) => Buffer[]);
          }], readonly ["deposit", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, options: Options): Buffer;
              serializeAettos(value: undefined | string): string;
          }]];
      };
      41: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ContractCall);
              serialize: ((value?: ContractCall) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["callerId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["callerNonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["height", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["contractId", {
              deserialize: ((value: Buffer) => `ct_${string}`);
              serialize: ((value: `ct_${string}`) => Buffer);
          }], readonly ["gasPrice", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value?: undefined | string): string;
          }], readonly ["gasUsed", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["returnValue", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `cb_${string}`) => Buffer);
          }], readonly ["returnType", {
              deserialize: ((value: Buffer) => CallReturnType);
              serialize: ((value: CallReturnType) => Buffer);
          }], readonly ["log", {
              deserialize(buffer: Buffer): Buffer;
              serialize(buffer: Uint8Array): Buffer;
          }]];
      };
      42: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ContractCreateTx);
              serialize: ((value?: ContractCreateTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["ownerId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["code", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `cb_${string}`) => Buffer);
          }], readonly ["ctVersion", {
              deserialize(buffer: Buffer): CtVersion;
              serialize(value: undefined | CtVersion, __namedParameters: {
                  consensusProtocolVersion: Iris;
              }): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["deposit", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, options: Options): Buffer;
              serializeAettos(value: undefined | string): string;
          }], readonly ["amount", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value: undefined | string): string;
          }], readonly ["gasLimit", {
              deserialize(value: Buffer): number;
              serialize(_value: undefined | number, __namedParameters: {
                  _computingGasLimit?: number;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  gasMax: number;
                  rebuildTx: ((params: any) => any);
                  tag: Tag;
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): Buffer;
          }], readonly ["gasPrice", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value?: undefined | string): string;
          }], readonly ["callData", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `cb_${string}`) => Buffer);
          }]];
      };
      43: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ContractCallTx);
              serialize: ((value?: ContractCallTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["callerId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["contractId", {
              deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
              serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
          }], readonly ["abiVersion", {
              deserialize(buffer: Buffer): AbiVersion;
              serialize(value: undefined | AbiVersion, __namedParameters: {
                  consensusProtocolVersion: Iris;
                  tag: Tag;
              }): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["amount", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value: undefined | string): string;
          }], readonly ["gasLimit", {
              deserialize(value: Buffer): number;
              serialize(_value: undefined | number, __namedParameters: {
                  _computingGasLimit?: number;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  gasMax: number;
                  rebuildTx: ((params: any) => any);
                  tag: Tag;
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): Buffer;
          }], readonly ["gasPrice", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value?: undefined | string): string;
          }], readonly ["callData", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `cb_${string}`) => Buffer);
          }]];
      };
      50: {
          2: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelCreateTx);
              serialize: ((value?: ChannelCreateTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 2);
              serialize: ((value?: 2) => Buffer);
          }], readonly ["initiator", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["initiatorAmount", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["responder", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["responderAmount", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["channelReserve", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["lockPeriod", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["initiatorDelegateIds", {
              deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
              serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
          }], readonly ["responderDelegateIds", {
              deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
              serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
          }], readonly ["stateHash", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `st_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      51: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelDepositTx);
              serialize: ((value?: ChannelDepositTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["channelId", {
              deserialize: ((value: Buffer) => `ch_${string}`);
              serialize: ((value: `ch_${string}`) => Buffer);
          }], readonly ["fromId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["amount", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["stateHash", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `st_${string}`) => Buffer);
          }], readonly ["round", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      52: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelWithdrawTx);
              serialize: ((value?: ChannelWithdrawTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["channelId", {
              deserialize: ((value: Buffer) => `ch_${string}`);
              serialize: ((value: `ch_${string}`) => Buffer);
          }], readonly ["toId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["amount", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["stateHash", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `st_${string}`) => Buffer);
          }], readonly ["round", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      521: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelForceProgressTx);
              serialize: ((value?: ChannelForceProgressTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["channelId", {
              deserialize: ((value: Buffer) => `ch_${string}`);
              serialize: ((value: `ch_${string}`) => Buffer);
          }], readonly ["fromId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["payload", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `tx_${string}`) => Buffer);
          }], readonly ["round", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["update", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `cb_${string}`) => Buffer);
          }], readonly ["stateHash", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `st_${string}`) => Buffer);
          }], readonly ["offChainTrees", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `ss_${string}`) => Buffer);
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      53: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelCloseMutualTx);
              serialize: ((value?: ChannelCloseMutualTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["channelId", {
              deserialize: ((value: Buffer) => `ch_${string}`);
              serialize: ((value: `ch_${string}`) => Buffer);
          }], readonly ["fromId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["initiatorAmountFinal", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["responderAmountFinal", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      54: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelCloseSoloTx);
              serialize: ((value?: ChannelCloseSoloTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["channelId", {
              deserialize: ((value: Buffer) => `ch_${string}`);
              serialize: ((value: `ch_${string}`) => Buffer);
          }], readonly ["fromId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["payload", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `tx_${string}`) => Buffer);
          }], readonly ["poi", {
              deserialize: ((value: Buffer, options: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }) => any);
              serialize: ((value: any, options: {
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
              }) => Buffer);
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      55: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelSlashTx);
              serialize: ((value?: ChannelSlashTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["channelId", {
              deserialize: ((value: Buffer) => `ch_${string}`);
              serialize: ((value: `ch_${string}`) => Buffer);
          }], readonly ["fromId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["payload", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `tx_${string}`) => Buffer);
          }], readonly ["poi", {
              deserialize: ((value: Buffer, options: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }) => any);
              serialize: ((value: any, options: {
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
              }) => Buffer);
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      56: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelSettleTx);
              serialize: ((value?: ChannelSettleTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["channelId", {
              deserialize: ((value: Buffer) => `ch_${string}`);
              serialize: ((value: `ch_${string}`) => Buffer);
          }], readonly ["fromId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["initiatorAmountFinal", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["responderAmountFinal", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      57: {
          2: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelOffChainTx);
              serialize: ((value?: ChannelOffChainTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 2);
              serialize: ((value?: 2) => Buffer);
          }], readonly ["channelId", {
              deserialize: ((value: Buffer) => `ch_${string}`);
              serialize: ((value: `ch_${string}`) => Buffer);
          }], readonly ["round", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["stateHash", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `st_${string}`) => Buffer);
          }]];
      };
      570: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelOffChainUpdateTransfer);
              serialize: ((value?: ChannelOffChainUpdateTransfer) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["from", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["to", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["amount", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }]];
      };
      571: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelOffChainUpdateDeposit);
              serialize: ((value?: ChannelOffChainUpdateDeposit) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["from", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["amount", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }]];
      };
      572: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelOffChainUpdateWithdraw);
              serialize: ((value?: ChannelOffChainUpdateWithdraw) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["from", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["amount", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }]];
      };
      573: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelOffChainUpdateCreateContract);
              serialize: ((value?: ChannelOffChainUpdateCreateContract) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["owner", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["ctVersion", {
              deserialize(buffer: Buffer): CtVersion;
              serialize(value: undefined | CtVersion, __namedParameters: {
                  consensusProtocolVersion: Iris;
              }): Buffer;
          }], readonly ["code", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `cb_${string}`) => Buffer);
          }], readonly ["deposit", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["callData", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `cb_${string}`) => Buffer);
          }]];
      };
      574: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelOffChainUpdateCallContract);
              serialize: ((value?: ChannelOffChainUpdateCallContract) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["caller", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["contract", {
              deserialize: ((value: Buffer) => `ct_${string}`);
              serialize: ((value: `ct_${string}`) => Buffer);
          }], readonly ["abiVersion", {
              deserialize(buffer: Buffer): AbiVersion;
              serialize(value: undefined | AbiVersion, __namedParameters: {
                  consensusProtocolVersion: Iris;
                  tag: Tag;
              }): Buffer;
          }], readonly ["amount", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["callData", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `cb_${string}`) => Buffer);
          }], readonly ["callStack", {
              deserialize(buffer: Buffer): Buffer;
              serialize(buffer: Uint8Array): Buffer;
          }], readonly ["gasPrice", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value?: undefined | string): string;
          }], readonly ["gasLimit", {
              deserialize(value: Buffer): number;
              serialize(_value: undefined | number, __namedParameters: {
                  _computingGasLimit?: number;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  gasMax: number;
                  rebuildTx: ((params: any) => any);
                  tag: Tag;
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): Buffer;
          }]];
      };
      575: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelClientReconnectTx);
              serialize: ((value?: ChannelClientReconnectTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["channelId", {
              deserialize: ((value: Buffer) => `ch_${string}`);
              serialize: ((value: `ch_${string}`) => Buffer);
          }], readonly ["round", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["role", {
              deserialize(buffer: Buffer): string;
              serialize(string: string): Buffer;
          }], readonly ["pubkey", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }]];
      };
      58: {
          3: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => Channel);
              serialize: ((value?: Channel) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 3);
              serialize: ((value?: 3) => Buffer);
          }], readonly ["initiator", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["responder", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["channelAmount", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["initiatorAmount", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["responderAmount", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["channelReserve", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["initiatorDelegateIds", {
              deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
              serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
          }], readonly ["responderDelegateIds", {
              deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
              serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
          }], readonly ["stateHash", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `st_${string}`) => Buffer);
          }], readonly ["round", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["soloRound", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["lockPeriod", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["lockedUntil", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["initiatorAuth", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `cb_${string}`) => Buffer);
          }], readonly ["responderAuth", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `cb_${string}`) => Buffer);
          }]];
      };
      59: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelSnapshotSoloTx);
              serialize: ((value?: ChannelSnapshotSoloTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["channelId", {
              deserialize: ((value: Buffer) => `ch_${string}`);
              serialize: ((value: `ch_${string}`) => Buffer);
          }], readonly ["fromId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["payload", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `tx_${string}`) => Buffer);
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      60: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => TreesPoi);
              serialize: ((value?: TreesPoi) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["accounts", {
              deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<AccountAddress, Account>[]);
              serialize: ((value: MPTree<AccountAddress, Account>[], params: unknown) => MPTreeBinary[]);
          }], readonly ["calls", {
              deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<Bytearray, ContractCall>[]);
              serialize: ((value: MPTree<Bytearray, ContractCall>[], params: unknown) => MPTreeBinary[]);
          }], readonly ["channels", {
              deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<Channel, Channel>[]);
              serialize: ((value: MPTree<Channel, Channel>[], params: unknown) => MPTreeBinary[]);
          }], readonly ["contracts", {
              deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<ContractAddress, Contract>[]);
              serialize: ((value: MPTree<ContractAddress, Contract>[], params: unknown) => MPTreeBinary[]);
          }], readonly ["ns", {
              deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<Name, Name>[]);
              serialize: ((value: MPTree<Name, Name>[], params: unknown) => MPTreeBinary[]);
          }], readonly ["oracles", {
              deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<OracleAddress, Oracle>[]);
              serialize: ((value: MPTree<OracleAddress, Oracle>[], params: unknown) => MPTreeBinary[]);
          }]];
      };
      62: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => StateTrees);
              serialize: ((value?: StateTrees) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["contracts", {
              deserialize: ((value: Buffer, options: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }) => any);
              serialize: ((value: any, options: {
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
              }) => Buffer);
          }], readonly ["calls", {
              deserialize: ((value: Buffer, options: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }) => any);
              serialize: ((value: any, options: {
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
              }) => Buffer);
          }], readonly ["channels", {
              deserialize: ((value: Buffer, options: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }) => any);
              serialize: ((value: any, options: {
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
              }) => Buffer);
          }], readonly ["ns", {
              deserialize: ((value: Buffer, options: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }) => any);
              serialize: ((value: any, options: {
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
              }) => Buffer);
          }], readonly ["oracles", {
              deserialize: ((value: Buffer, options: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }) => any);
              serialize: ((value: any, options: {
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
              }) => Buffer);
          }], readonly ["accounts", {
              deserialize: ((value: Buffer, options: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }) => any);
              serialize: ((value: any, options: {
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
              }) => Buffer);
          }]];
      };
      621: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ContractsMtree);
              serialize: ((value?: ContractsMtree) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["contracts", {
              deserialize: ((value: Buffer, options: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }) => any);
              serialize: ((value: any, options: {
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
              }) => Buffer);
          }]];
      };
      622: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => CallsMtree);
              serialize: ((value?: CallsMtree) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["calls", {
              deserialize: ((value: Buffer, options: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }) => any);
              serialize: ((value: any, options: {
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
              }) => Buffer);
          }]];
      };
      623: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelsMtree);
              serialize: ((value?: ChannelsMtree) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["channels", {
              deserialize: ((value: Buffer, options: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }) => any);
              serialize: ((value: any, options: {
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
              }) => Buffer);
          }]];
      };
      624: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => NameserviceMtree);
              serialize: ((value?: NameserviceMtree) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["mtree", {
              deserialize: ((value: Buffer, options: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }) => any);
              serialize: ((value: any, options: {
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
              }) => Buffer);
          }]];
      };
      625: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => OraclesMtree);
              serialize: ((value?: OraclesMtree) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["otree", {
              deserialize: ((value: Buffer, options: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }) => any);
              serialize: ((value: any, options: {
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
              }) => Buffer);
          }]];
      };
      626: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => AccountsMtree);
              serialize: ((value?: AccountsMtree) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["accounts", {
              deserialize: ((value: Buffer, options: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }) => any);
              serialize: ((value: any, options: {
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
              }) => Buffer);
          }]];
      };
      63: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => Mtree);
              serialize: ((value?: Mtree) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["values", {
              deserialize: ((value: Buffer[], params: unknown) => any[]);
              serialize: ((value: any[], params: unknown) => Buffer[]);
          }]];
      };
      64: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => MtreeValue);
              serialize: ((value?: MtreeValue) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["key", {
              deserialize(buffer: Buffer): Buffer;
              serialize(buffer: Uint8Array): Buffer;
          }], readonly ["value", {
              deserialize(buffer: Buffer): Buffer;
              serialize(buffer: Uint8Array): Buffer;
          }]];
      };
      80: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => GaAttachTx);
              serialize: ((value?: GaAttachTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["ownerId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["code", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `cb_${string}`) => Buffer);
          }], readonly ["authFun", {
              deserialize(buffer: Buffer): Buffer;
              serialize(buffer: Uint8Array): Buffer;
          }], readonly ["ctVersion", {
              deserialize(buffer: Buffer): CtVersion;
              serialize(value: undefined | CtVersion, __namedParameters: {
                  consensusProtocolVersion: Iris;
              }): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["gasLimit", {
              deserialize(value: Buffer): number;
              serialize(_value: undefined | number, __namedParameters: {
                  _computingGasLimit?: number;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  gasMax: number;
                  rebuildTx: ((params: any) => any);
                  tag: Tag;
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): Buffer;
          }], readonly ["gasPrice", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value?: undefined | string): string;
          }], readonly ["callData", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `cb_${string}`) => Buffer);
          }]];
      };
      81: {
          2: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => GaMetaTx);
              serialize: ((value?: GaMetaTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 2);
              serialize: ((value?: 2) => Buffer);
          }], readonly ["gaId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["authData", {
              deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
              serialize: ((value: `cb_${string}`) => Buffer);
          }], readonly ["abiVersion", {
              deserialize(buffer: Buffer): AbiVersion;
              serialize(value: undefined | AbiVersion, __namedParameters: {
                  consensusProtocolVersion: Iris;
                  tag: Tag;
              }): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["gasLimit", {
              deserialize(value: Buffer): number;
              serialize(_value: undefined | number, __namedParameters: {
                  _computingGasLimit?: number;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  gasMax: number;
                  rebuildTx: ((params: any) => any);
                  tag: Tag;
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): Buffer;
          }], readonly ["gasPrice", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value?: undefined | string): string;
          }], readonly ["tx", {
              deserialize: ((value: Buffer, options: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }) => any);
              serialize: ((value: any, options: {
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
              }) => Buffer);
          }]];
      };
      82: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => PayingForTx);
              serialize: ((value?: PayingForTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["payerId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["tx", {
              deserialize: ((value: Buffer, options: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
              }) => any);
              serialize: ((value: any, options: {
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
              }) => Buffer);
          }]];
      };
  }[TxType]>, number>>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
      gasMax?: number;
  } : {}), "nonce" | "ttl" | "tag"> & {
      absoluteTtl?: boolean;
      denomination?: AE_AMOUNT_FORMATS;
      nonce?: number;
      onNode: Node;
      strategy?: "max" | "continuity";
      ttl?: number;
  } & (TxType extends OracleResponseTx | OracleExtendTx ? {
      callerId: `ak_${string}`;
  } : {}), "onNode"> & {
      onNode?: Node;
  }
Returns Promise<`tx_${string}`>
Inherited from AeSdkBase.buildTx
- Defined in AeSdkMethods.ts:103

`Protected` ensureNodeConnected

ensureNodeConnected(): asserts this is AeSdkBase & {
selectedNodeName: string;
}
Returns asserts this is AeSdkBase & {
selectedNodeName: string;
}
Inherited from AeSdkBase.ensureNodeConnected
- Defined in AeSdkBase.ts:90

getNodeInfo

getNodeInfo(): Promise<NodeInfo>
Get information about node

Example
```
nodePool.getNodeInfo() // { name, version, networkId, protocol, ... }
```
Returns Promise<NodeInfo>
Inherited from AeSdkBase.getNodeInfo
- Defined in AeSdkBase.ts:103

getNodesInPool

getNodesInPool(): Promise<NodeInfo[]>
Get array of available nodes

Example
```
nodePool.getNodesInPool()
```
Returns Promise<NodeInfo[]>
Inherited from AeSdkBase.getNodesInPool
- Defined in AeSdkBase.ts:116

initializeContract

initializeContract<Methods>(options?: Omit<Omit<{
    aci: Aci;
    address?: `ct_${string}`;
    bytecode?: `cb_${string}`;
    fileSystem?: Record<string, string>;
    onCompiler?: CompilerBase;
    onNode: Node;
    sourceCode?: string;
    sourceCodePath?: string;
} & Partial<BuildTxOptions<ContractCallTx, "callData" | "callerId" | "contractId">> & {
    omitUnknown?: boolean;
} & {
    contractAddressToName?: {
        [key: ContractAddress]: string;
    };
} & Omit<SendOptions, "onNode" | "onAccount"> & Omit<{
    combine?: boolean;
    onNode: Node;
    top?: number | `kh_${string}` | `mh_${string}`;
    txEvents?: boolean;
}, "onNode"> & {
    callStatic?: boolean;
    onAccount?: AccountBase;
    onNode?: Node;
} & Partial<BuildTxOptions<ContractCreateTx, "code" | "ownerId" | "callData">>, "address" | "aci"> & {
    aci?: Aci;
    address?: `${string}.chain` | `ct_${string}`;
    validateBytecode?: boolean;
}, "onNode"> & {
    onNode?: Node;
}): Promise<Contract<Methods>>
Type Parameters
- Methods extends ContractMethodsBase
Parameters
- Optional options: Omit<Omit<{
      aci: Aci;
      address?: `ct_${string}`;
      bytecode?: `cb_${string}`;
      fileSystem?: Record<string, string>;
      onCompiler?: CompilerBase;
      onNode: Node;
      sourceCode?: string;
      sourceCodePath?: string;
  } & Partial<BuildTxOptions<ContractCallTx, "callData" | "callerId" | "contractId">> & {
      omitUnknown?: boolean;
  } & {
      contractAddressToName?: {
          [key: ContractAddress]: string;
      };
  } & Omit<SendOptions, "onNode" | "onAccount"> & Omit<{
      combine?: boolean;
      onNode: Node;
      top?: number | `kh_${string}` | `mh_${string}`;
      txEvents?: boolean;
  }, "onNode"> & {
      callStatic?: boolean;
      onAccount?: AccountBase;
      onNode?: Node;
  } & Partial<BuildTxOptions<ContractCreateTx, "code" | "ownerId" | "callData">>, "address" | "aci"> & {
      aci?: Aci;
      address?: `${string}.chain` | `ct_${string}`;
      validateBytecode?: boolean;
  }, "onNode"> & {
      onNode?: Node;
  }
Returns Promise<Contract<Methods>>
Inherited from AeSdkBase.initializeContract
- Defined in AeSdkMethods.ts:114

isNodeConnected

isNodeConnected(): this is AeSdkBase & {
selectedNodeName: string;
}
Check if you have selected node

Example
```
nodePool.isNodeConnected()
```
Returns this is AeSdkBase & {
selectedNodeName: string;
}
Inherited from AeSdkBase.isNodeConnected
- Defined in AeSdkBase.ts:86

removeAccount

removeAccount(address: `ak_${string}`): void
Remove specific account

Example
```
removeAccount(address)
```
Parameters
- address: `ak_${string}`
  
  Address of account to remove
Returns void
- Defined in AeSdk.ts:56

selectAccount

selectAccount(address: `ak_${string}`): void
Select specific account

Example
```
selectAccount('ak_xxxxxxxx')
```
Parameters
- address: `ak_${string}`
  
  Address of account to select
Returns void
- Defined in AeSdk.ts:67

selectNode

selectNode(name: string): void
Select Node

Example
```
nodePool.selectNode('testNode')
```
Parameters
- name: string
  
  Node name
Returns void
Inherited from AeSdkBase.selectNode
- Defined in AeSdkBase.ts:76

sign

sign(data: string | Uint8Array, __namedParameters?: {
onAccount?: OnAccount;
}): Promise<Uint8Array>
Parameters
- data: string | Uint8Array
- __namedParameters: {
  onAccount?: OnAccount;
  } = {}
  - Optional onAccount?: OnAccount
Returns Promise<Uint8Array>
Inherited from AeSdkBase.sign
- Defined in AeSdkBase.ts:134

signMessage

signMessage(message: string, __namedParameters?: {
    onAccount?: OnAccount;
} & {
    aeppOrigin?: string;
    aeppRpcClientId?: string;
}): Promise<Uint8Array>
Parameters
- message: string
- __namedParameters: {
      onAccount?: OnAccount;
  } & {
      aeppOrigin?: string;
      aeppRpcClientId?: string;
  } = {}
Returns Promise<Uint8Array>
Inherited from AeSdkBase.signMessage
- Defined in AeSdkBase.ts:149

signTransaction

signTransaction(tx: `tx_${string}`, __namedParameters?: {
    onAccount?: OnAccount;
} & {
    aeppOrigin?: string;
    aeppRpcClientId?: string;
    authData?: {
        args?: any[];
        callData?: `cb_${string}`;
        gasLimit?: number;
        sourceCode?: string;
    };
    innerTx?: boolean;
    networkId?: string;
    onCompiler?: CompilerBase;
    onNode?: Node;
}): Promise<`tx_${string}`>
Parameters
- tx: `tx_${string}`
- __namedParameters: {
      onAccount?: OnAccount;
  } & {
      aeppOrigin?: string;
      aeppRpcClientId?: string;
      authData?: {
          args?: any[];
          callData?: `cb_${string}`;
          gasLimit?: number;
          sourceCode?: string;
      };
      innerTx?: boolean;
      networkId?: string;
      onCompiler?: CompilerBase;
      onNode?: Node;
  } = {}
Returns Promise<`tx_${string}`>
Inherited from AeSdkBase.signTransaction
- Defined in AeSdkBase.ts:141

Class AeSdk

Hierarchy

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

__namedParameters: { accounts?: AccountBase[]; } & AeSdkMethodsOptions & { nodes?: { instance: Node; name: string; }[]; } = {}

Returns AeSdk

Properties

_getPollInterval

Type declaration

Parameters

Rest ...args: ["block" | "microblock"] | ["block" | "microblock", Omit<{ _expectedMineRate?: number; _maxPollInterval?: number; _microBlockCycle?: number; }, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

Returns number

_options

accounts

Type declaration

[key: AccountAddress]: AccountBase

aensBid

Type declaration

Parameters

Rest ...args: [name: `${string}.chain`, nameFee: string | number | BigNumber] | [`${string}.chain`, string | number | BigNumber, Omit<Omit<AensClaimOptions, "nameFee">, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

Returns Promise<AensClaimReturnType>

aensClaim

Type declaration

Parameters

Rest ...args: [name: `${string}.chain`, salt: number] | [`${string}.chain`, number, Omit<AensClaimOptions, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

Returns Promise<AensClaimReturnType>

aensPreclaim

Type declaration

Parameters

Rest ...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensPreclaimOptions, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

Returns Promise<Readonly<SendReturnType & { claim: ((opts?: AensClaimOptions) => Promise<AensClaimReturnType>); commitmentId: string; height: number; salt: number; }>>

aensQuery

Type declaration

Parameters

Rest ...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

aensRevoke

Type declaration

Parameters

Rest ...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

Returns Promise<SendReturnType>

aensTransfer

Type declaration

Parameters

Rest ...args: [name: `${string}.chain`, account: `ak_${string}`] | [`${string}.chain`, `ak_${string}`, Omit<AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

Returns Promise<SendReturnType>

aensUpdate

Type declaration

Parameters

Rest ...args: [`${string}.chain`, KeyPointers] | [`${string}.chain`, KeyPointers, Omit<AensUpdateOptions, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

Returns Promise<SendReturnType>

awaitHeight

Type declaration

Parameters

Rest ...args: [number] | [number, Omit<{ interval?: number; onNode: Node; } & { _expectedMineRate?: number; _maxPollInterval?: number; _microBlockCycle?: number; }, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

Returns Promise<number>

buildAuthTxHash

Type declaration

Parameters

Rest ...args: [`tx_${string}`] | [`tx_${string}`, Omit<{ onNode: Node; }, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

Returns Promise<Uint8Array>

createGeneralizedAccount

Type declaration

Parameters

Rest ...args: [string, any[]] | [string, any[], Omit<CreateGeneralizedAccountOptions, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

Returns Promise<Readonly<{ gaContractId: `ct_${string}`; owner: `ak_${string}`; rawTx: `tx_${string}`; transaction: `th_${string}`; }>>

extendOracleTtl

Type declaration

Parameters

Rest ...args: [oracleId: `ok_${string}`] | [`ok_${string}`, Omit<ExtendOracleTtlOptions, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

Returns Promise<SendReturnType & GetOracleObjectReturnType>

getAccount

Type declaration

Parameters

Rest ...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{ hash?: `kh_${string}` | `mh_${string}`; height?: number; onNode: Node; }, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

__namedParameters: {
accounts?: AccountBase[];
} & AeSdkMethodsOptions & {
nodes?: {
instance: Node;
name: string;
}[];
} = {}

`Rest` ...args: ["block" | "microblock"] | ["block" | "microblock", Omit<{
_expectedMineRate?: number;
_maxPollInterval?: number;
_microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [name: `${string}.chain`, nameFee: string | number | BigNumber] | [`${string}.chain`, string | number | BigNumber, Omit<Omit<AensClaimOptions, "nameFee">, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [name: `${string}.chain`, salt: number] | [`${string}.chain`, number, Omit<AensClaimOptions, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensPreclaimOptions, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

Returns Promise<Readonly<SendReturnType & {
claim: ((opts?: AensClaimOptions) => Promise<AensClaimReturnType>);
commitmentId: string;
height: number;
salt: number;
}>>

`Rest` ...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<{
onNode: Node;
} & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [name: `${string}.chain`, account: `ak_${string}`] | [`${string}.chain`, `ak_${string}`, Omit<AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [`${string}.chain`, KeyPointers] | [`${string}.chain`, KeyPointers, Omit<AensUpdateOptions, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [number] | [number, Omit<{
interval?: number;
onNode: Node;
} & {
_expectedMineRate?: number;
_maxPollInterval?: number;
_microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [`tx_${string}`] | [`tx_${string}`, Omit<{
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [string, any[]] | [string, any[], Omit<CreateGeneralizedAccountOptions, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

Returns Promise<Readonly<{
gaContractId: `ct_${string}`;
owner: `ak_${string}`;
rawTx: `tx_${string}`;
transaction: `th_${string}`;
}>>

`Rest` ...args: [oracleId: `ok_${string}`] | [`ok_${string}`, Omit<ExtendOracleTtlOptions, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
hash?: `kh_${string}` | `mh_${string}`;
height?: number;
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

Returns Promise<{
authFun?: string;
balance: bigint;
contractId?: string;
id: string;
kind?: AccountKind;
nonce: number;
payable?: boolean;
}>

`Rest` ...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

Returns Promise<{
abiVersion: string;
active: boolean;
deposit: bigint;
id: string;
ownerId: string;
referrerIds: string[];
vmVersion: string;
}>

`Rest` ...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

Returns Promise<{
bytecode: `cb_${string}`;
}>

`Rest` ...args: [] | [Omit<{
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

Returns Promise<{
keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
microBlocks: string[];
}>

`Rest` ...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

Returns Promise<{
keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
microBlocks: string[];
}>

`Rest` ...args: [] | [Omit<{
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

Returns Promise<{
beneficiary: string;
hash: string;
height: number;
info: string;
miner: string;
nonce?: number;
pow?: string[];
prevHash: string;
prevKeyHash: string;
stateHash: string;
target: string;
time: number;
version: number;
}>

`Rest` ...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

Returns Promise<{
hash: string;
height: number;
pofHash: string;
prevHash: string;
prevKeyHash: string;
signature: string;
stateHash: string;
time: number;
txsHash: string;
version: number;
}>

`Rest` ...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [`${string}.chain`] | [`${string}.chain`, Omit<{
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

Returns Promise<{
id: string;
owner?: string;
pointers: ({ key: string; id: string; })[];
ttl: number;
}>

`Rest` ...args: [oracleId: `ok_${string}`] | [`ok_${string}`, Omit<{
onAccount: AccountBase;
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [transaction: `tx_${string}`] | [`tx_${string}`, Omit<PayForTransactionOptions, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]